]> 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
Base class factory on the wxFilter base class and implement the new Find feature.
[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 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
3486 }
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3792 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3793 return wxPyTestDisplayAvailable();
3794 }
3795
3796 void wxApp_CleanUp() {
3797 __wxPyCleanup();
3798 }
3799
3800
3801 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3802
3803
3804
3805
3806
3807 SWIGINTERNINLINE PyObject *
3808 SWIG_FromCharPtr(const char *cptr)
3809 {
3810 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3811 }
3812
3813
3814 #if 0 // #ifdef __WXMAC__
3815
3816 // A dummy class that raises an exception if used...
3817 class wxEventLoop
3818 {
3819 public:
3820 wxEventLoop() { wxPyRaiseNotImplemented(); }
3821 int Run() { return 0; }
3822 void Exit(int rc = 0) {}
3823 bool Pending() const { return false; }
3824 bool Dispatch() { return false; }
3825 bool IsRunning() const { return false; }
3826 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3827 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3828 };
3829
3830 #else
3831
3832 #include <wx/evtloop.h>
3833
3834 #endif
3835
3836
3837
3838 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3839 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3840 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3841 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3842 wxWindowList& list = self->GetChildren();
3843 return wxPy_ConvertList(&list);
3844 }
3845 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3846 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3847 #if wxUSE_HOTKEY
3848 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3849 #else
3850 return false;
3851 #endif
3852 }
3853 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3854
3855
3856
3857 return false;
3858
3859 }
3860 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3861 return wxPyGetWinHandle(self);
3862 }
3863 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3864 self->AssociateHandle((WXWidget)handle);
3865 }
3866 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3867
3868 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3869 return wxWindow::FindWindowById(id, parent);
3870 }
3871
3872 wxWindow* wxFindWindowByName( const wxString& name,
3873 const wxWindow *parent = NULL ) {
3874 return wxWindow::FindWindowByName(name, parent);
3875 }
3876
3877 wxWindow* wxFindWindowByLabel( const wxString& label,
3878 const wxWindow *parent = NULL ) {
3879 return wxWindow::FindWindowByLabel(label, parent);
3880 }
3881
3882
3883 #ifdef __WXMSW__
3884 #include <wx/msw/private.h> // to get wxGetWindowId
3885 #endif
3886
3887
3888 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3889 #ifdef __WXMSW__
3890 WXHWND hWnd = (WXHWND)_hWnd;
3891 long id = wxGetWindowId(hWnd);
3892 wxWindow* win = new wxWindow;
3893 if (parent)
3894 parent->AddChild(win);
3895 win->SetEventHandler(win);
3896 win->SetHWND(hWnd);
3897 win->SetId(id);
3898 win->SubclassWin(hWnd);
3899 win->AdoptAttributesFromHWND();
3900 win->SetupColours();
3901 return win;
3902 #else
3903 wxPyRaiseNotImplemented();
3904 return NULL;
3905 #endif
3906 }
3907
3908
3909 PyObject* GetTopLevelWindows() {
3910 return wxPy_ConvertList(&wxTopLevelWindows);
3911 }
3912
3913
3914 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3915 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3916 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3917
3918 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3919
3920
3921 SWIGINTERNINLINE int
3922 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3923 {
3924 unsigned long v;
3925 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3926 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3927 return res;
3928 }
3929
3930 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3931 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3932 wxMenuItemList& list = self->GetMenuItems();
3933 return wxPy_ConvertList(&list);
3934 }
3935 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3936 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3937 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3938 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3940 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3941 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3942 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3943 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3944 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3945 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3946 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3947 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3948 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3949 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3950 static const wxString wxPyControlNameStr(wxControlNameStr);
3951 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3952 if (clientData) {
3953 wxPyClientData* data = new wxPyClientData(clientData);
3954 return self->Append(item, data);
3955 } else
3956 return self->Append(item);
3957 }
3958 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3959 if (clientData) {
3960 wxPyClientData* data = new wxPyClientData(clientData);
3961 return self->Insert(item, pos, data);
3962 } else
3963 return self->Insert(item, pos);
3964 }
3965 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3966 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3967 if (data) {
3968 Py_INCREF(data->m_obj);
3969 return data->m_obj;
3970 } else {
3971 Py_INCREF(Py_None);
3972 return Py_None;
3973 }
3974 }
3975 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3976 wxPyClientData* data = new wxPyClientData(clientData);
3977 self->SetClientObject(n, data);
3978 }
3979
3980
3981 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3982 wxPyUserData* data = NULL;
3983 if ( userData ) {
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 data = new wxPyUserData(userData);
3986 wxPyEndBlockThreads(blocked);
3987 }
3988 return new wxSizerItem(window, proportion, flag, border, data);
3989 }
3990 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3991 wxPyUserData* data = NULL;
3992 if ( userData ) {
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 data = new wxPyUserData(userData);
3995 wxPyEndBlockThreads(blocked);
3996 }
3997 return new wxSizerItem(width, height, proportion, flag, border, data);
3998 }
3999 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4000 wxPyUserData* data = NULL;
4001 if ( userData ) {
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 data = new wxPyUserData(userData);
4004 wxPyEndBlockThreads(blocked);
4005 }
4006 return new wxSizerItem(sizer, proportion, flag, border, data);
4007 }
4008
4009 SWIGINTERNINLINE PyObject *
4010 SWIG_From_float (float value)
4011 {
4012 return SWIG_From_double (value);
4013 }
4014
4015 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4016 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4017 if (data) {
4018 Py_INCREF(data->m_obj);
4019 return data->m_obj;
4020 } else {
4021 Py_INCREF(Py_None);
4022 return Py_None;
4023 }
4024 }
4025 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4026 wxPyUserData* data = NULL;
4027 if ( userData ) {
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 data = new wxPyUserData(userData);
4030 wxPyEndBlockThreads(blocked);
4031 }
4032 self->SetUserData(data);
4033 }
4034
4035 // Figure out the type of the sizer item
4036
4037 struct wxPySizerItemInfo {
4038 wxPySizerItemInfo()
4039 : window(NULL), sizer(NULL), gotSize(false),
4040 size(wxDefaultSize), gotPos(false), pos(-1)
4041 {}
4042
4043 wxWindow* window;
4044 wxSizer* sizer;
4045 bool gotSize;
4046 wxSize size;
4047 bool gotPos;
4048 int pos;
4049 };
4050
4051 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4052
4053 wxPySizerItemInfo info;
4054 wxSize size;
4055 wxSize* sizePtr = &size;
4056
4057 // Find out what the type of the item is
4058 // try wxWindow
4059 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4060 PyErr_Clear();
4061 info.window = NULL;
4062
4063 // try wxSizer
4064 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4065 PyErr_Clear();
4066 info.sizer = NULL;
4067
4068 // try wxSize or (w,h)
4069 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4070 info.size = *sizePtr;
4071 info.gotSize = true;
4072 }
4073
4074 // or a single int
4075 if (checkIdx && PyInt_Check(item)) {
4076 info.pos = PyInt_AsLong(item);
4077 info.gotPos = true;
4078 }
4079 }
4080 }
4081
4082 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4083 // no expected type, figure out what kind of error message to generate
4084 if ( !checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4086 else if ( checkSize && !checkIdx )
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4088 else if ( !checkSize && checkIdx)
4089 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4090 else
4091 // can this one happen?
4092 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4093 }
4094
4095 return info;
4096 }
4097
4098 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4099 if (!self->GetClientObject())
4100 self->SetClientObject(new wxPyOORClientData(_self));
4101 }
4102 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4103
4104 wxPyUserData* data = NULL;
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4107 if ( userData && (info.window || info.sizer || info.gotSize) )
4108 data = new wxPyUserData(userData);
4109 if ( info.sizer )
4110 PyObject_SetAttrString(item,"thisown",Py_False);
4111 wxPyEndBlockThreads(blocked);
4112
4113 // Now call the real Add method if a valid item type was found
4114 if ( info.window )
4115 return self->Add(info.window, proportion, flag, border, data);
4116 else if ( info.sizer )
4117 return self->Add(info.sizer, proportion, flag, border, data);
4118 else if (info.gotSize)
4119 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4120 proportion, flag, border, data);
4121 else
4122 return NULL;
4123 }
4124 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4125
4126 wxPyUserData* data = NULL;
4127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4128 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4129 if ( userData && (info.window || info.sizer || info.gotSize) )
4130 data = new wxPyUserData(userData);
4131 if ( info.sizer )
4132 PyObject_SetAttrString(item,"thisown",Py_False);
4133 wxPyEndBlockThreads(blocked);
4134
4135 // Now call the real Insert method if a valid item type was found
4136 if ( info.window )
4137 return self->Insert(before, info.window, proportion, flag, border, data);
4138 else if ( info.sizer )
4139 return self->Insert(before, info.sizer, proportion, flag, border, data);
4140 else if (info.gotSize)
4141 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4142 proportion, flag, border, data);
4143 else
4144 return NULL;
4145 }
4146 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4147
4148 wxPyUserData* data = NULL;
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4151 if ( userData && (info.window || info.sizer || info.gotSize) )
4152 data = new wxPyUserData(userData);
4153 if ( info.sizer )
4154 PyObject_SetAttrString(item,"thisown",Py_False);
4155 wxPyEndBlockThreads(blocked);
4156
4157 // Now call the real Prepend method if a valid item type was found
4158 if ( info.window )
4159 return self->Prepend(info.window, proportion, flag, border, data);
4160 else if ( info.sizer )
4161 return self->Prepend(info.sizer, proportion, flag, border, data);
4162 else if (info.gotSize)
4163 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4164 proportion, flag, border, data);
4165 else
4166 return NULL;
4167 }
4168 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4171 wxPyEndBlockThreads(blocked);
4172 if ( info.window )
4173 return self->Remove(info.window);
4174 else if ( info.sizer )
4175 return self->Remove(info.sizer);
4176 else if ( info.gotPos )
4177 return self->Remove(info.pos);
4178 else
4179 return false;
4180 }
4181 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4184 wxPyEndBlockThreads(blocked);
4185 if ( info.window )
4186 return self->Detach(info.window);
4187 else if ( info.sizer )
4188 return self->Detach(info.sizer);
4189 else if ( info.gotPos )
4190 return self->Detach(info.pos);
4191 else
4192 return false;
4193 }
4194 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4197 wxPyEndBlockThreads(blocked);
4198 if ( info.window )
4199 return self->GetItem(info.window);
4200 else if ( info.sizer )
4201 return self->GetItem(info.sizer);
4202 else if ( info.gotPos )
4203 return self->GetItem(info.pos);
4204 else
4205 return NULL;
4206 }
4207 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 self->SetItemMinSize(info.window, size);
4213 else if ( info.sizer )
4214 self->SetItemMinSize(info.sizer, size);
4215 else if ( info.gotPos )
4216 self->SetItemMinSize(info.pos, size);
4217 }
4218 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4219 wxSizerItemList& list = self->GetChildren();
4220 return wxPy_ConvertList(&list);
4221 }
4222 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4225 wxPyEndBlockThreads(blocked);
4226 if ( info.window )
4227 return self->Show(info.window, show, recursive);
4228 else if ( info.sizer )
4229 return self->Show(info.sizer, show, recursive);
4230 else if ( info.gotPos )
4231 return self->Show(info.pos, show);
4232 else
4233 return false;
4234 }
4235 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4237 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4238 wxPyEndBlockThreads(blocked);
4239 if ( info.window )
4240 return self->IsShown(info.window);
4241 else if ( info.sizer )
4242 return self->IsShown(info.sizer);
4243 else if ( info.gotPos )
4244 return self->IsShown(info.pos);
4245 else
4246 return false;
4247 }
4248
4249 // See pyclasses.h
4250 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4251 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4252 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4253
4254
4255
4256
4257 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4258 {
4259 if (source == Py_None) {
4260 **obj = wxGBPosition(-1,-1);
4261 return true;
4262 }
4263 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4264 }
4265
4266 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4267 {
4268 if (source == Py_None) {
4269 **obj = wxGBSpan(-1,-1);
4270 return true;
4271 }
4272 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4273 }
4274
4275
4276 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4277 wxGBPosition temp, *obj = &temp;
4278 if ( other == Py_None ) return false;
4279 if ( ! wxGBPosition_helper(other, &obj) ) {
4280 PyErr_Clear();
4281 return false;
4282 }
4283 return self->operator==(*obj);
4284 }
4285 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4286 wxGBPosition temp, *obj = &temp;
4287 if ( other == Py_None ) return true;
4288 if ( ! wxGBPosition_helper(other, &obj)) {
4289 PyErr_Clear();
4290 return true;
4291 }
4292 return self->operator!=(*obj);
4293 }
4294 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4295 self->SetRow(row);
4296 self->SetCol(col);
4297 }
4298 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4300 PyObject* tup = PyTuple_New(2);
4301 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4302 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4303 wxPyEndBlockThreads(blocked);
4304 return tup;
4305 }
4306 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4307 wxGBSpan temp, *obj = &temp;
4308 if ( other == Py_None ) return false;
4309 if ( ! wxGBSpan_helper(other, &obj) ) {
4310 PyErr_Clear();
4311 return false;
4312 }
4313 return self->operator==(*obj);
4314 }
4315 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4316 wxGBSpan temp, *obj = &temp;
4317 if ( other == Py_None ) return true;
4318 if ( ! wxGBSpan_helper(other, &obj)) {
4319 PyErr_Clear();
4320 return true;
4321 }
4322 return self->operator!=(*obj);
4323 }
4324 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4325 self->SetRowspan(rowspan);
4326 self->SetColspan(colspan);
4327 }
4328 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4329 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4330 PyObject* tup = PyTuple_New(2);
4331 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4332 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4333 wxPyEndBlockThreads(blocked);
4334 return tup;
4335 }
4336 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4337 wxPyUserData* data = NULL;
4338 if ( userData ) {
4339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4340 data = new wxPyUserData(userData);
4341 wxPyEndBlockThreads(blocked);
4342 }
4343 return new wxGBSizerItem(window, pos, span, flag, border, data);
4344 }
4345 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4346 wxPyUserData* data = NULL;
4347 if ( userData ) {
4348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4349 data = new wxPyUserData(userData);
4350 wxPyEndBlockThreads(blocked);
4351 }
4352 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4353 }
4354 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4355 wxPyUserData* data = NULL;
4356 if ( userData ) {
4357 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4358 data = new wxPyUserData(userData);
4359 wxPyEndBlockThreads(blocked);
4360 }
4361 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4362 }
4363 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4364 int row, col;
4365 self->GetEndPos(row, col);
4366 return wxGBPosition(row, col);
4367 }
4368 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4369
4370 wxPyUserData* data = NULL;
4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4372 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4373 if ( userData && (info.window || info.sizer || info.gotSize) )
4374 data = new wxPyUserData(userData);
4375 if ( info.sizer )
4376 PyObject_SetAttrString(item,"thisown",Py_False);
4377 wxPyEndBlockThreads(blocked);
4378
4379 // Now call the real Add method if a valid item type was found
4380 if ( info.window )
4381 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4382 else if ( info.sizer )
4383 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4384 else if (info.gotSize)
4385 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4386 pos, span, flag, border, data);
4387 return NULL;
4388 }
4389
4390
4391 #ifdef __cplusplus
4392 extern "C" {
4393 #endif
4394 SWIGINTERN int EmptyString_set(PyObject *) {
4395 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4396 return 1;
4397 }
4398
4399
4400 SWIGINTERN PyObject *EmptyString_get(void) {
4401 PyObject *pyobj = 0;
4402
4403 {
4404 #if wxUSE_UNICODE
4405 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #else
4407 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4408 #endif
4409 }
4410 return pyobj;
4411 }
4412
4413
4414 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4415 PyObject *resultobj = 0;
4416 wxObject *arg1 = (wxObject *) 0 ;
4417 wxString result;
4418 void *argp1 = 0 ;
4419 int res1 = 0 ;
4420 PyObject *swig_obj[1] ;
4421
4422 if (!args) SWIG_fail;
4423 swig_obj[0] = args;
4424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4425 if (!SWIG_IsOK(res1)) {
4426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4427 }
4428 arg1 = reinterpret_cast< wxObject * >(argp1);
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = wxObject_GetClassName(arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 {
4436 #if wxUSE_UNICODE
4437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4438 #else
4439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4440 #endif
4441 }
4442 return resultobj;
4443 fail:
4444 return NULL;
4445 }
4446
4447
4448 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4449 PyObject *resultobj = 0;
4450 wxObject *arg1 = (wxObject *) 0 ;
4451 void *argp1 = 0 ;
4452 int res1 = 0 ;
4453 PyObject *swig_obj[1] ;
4454
4455 if (!args) SWIG_fail;
4456 swig_obj[0] = args;
4457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4460 }
4461 arg1 = reinterpret_cast< wxObject * >(argp1);
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 wxObject_Destroy(arg1);
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *obj;
4477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4478 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4479 return SWIG_Py_Void();
4480 }
4481
4482 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4483 PyObject *resultobj = 0;
4484 wxSize *arg1 = (wxSize *) 0 ;
4485 int arg2 ;
4486 void *argp1 = 0 ;
4487 int res1 = 0 ;
4488 int val2 ;
4489 int ecode2 = 0 ;
4490 PyObject *swig_obj[2] ;
4491
4492 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4494 if (!SWIG_IsOK(res1)) {
4495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4496 }
4497 arg1 = reinterpret_cast< wxSize * >(argp1);
4498 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4499 if (!SWIG_IsOK(ecode2)) {
4500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4501 }
4502 arg2 = static_cast< int >(val2);
4503 if (arg1) (arg1)->x = arg2;
4504
4505 resultobj = SWIG_Py_Void();
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4513 PyObject *resultobj = 0;
4514 wxSize *arg1 = (wxSize *) 0 ;
4515 int result;
4516 void *argp1 = 0 ;
4517 int res1 = 0 ;
4518 PyObject *swig_obj[1] ;
4519
4520 if (!args) SWIG_fail;
4521 swig_obj[0] = args;
4522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4523 if (!SWIG_IsOK(res1)) {
4524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4525 }
4526 arg1 = reinterpret_cast< wxSize * >(argp1);
4527 result = (int) ((arg1)->x);
4528 resultobj = SWIG_From_int(static_cast< int >(result));
4529 return resultobj;
4530 fail:
4531 return NULL;
4532 }
4533
4534
4535 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4536 PyObject *resultobj = 0;
4537 wxSize *arg1 = (wxSize *) 0 ;
4538 int arg2 ;
4539 void *argp1 = 0 ;
4540 int res1 = 0 ;
4541 int val2 ;
4542 int ecode2 = 0 ;
4543 PyObject *swig_obj[2] ;
4544
4545 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4547 if (!SWIG_IsOK(res1)) {
4548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4549 }
4550 arg1 = reinterpret_cast< wxSize * >(argp1);
4551 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4552 if (!SWIG_IsOK(ecode2)) {
4553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4554 }
4555 arg2 = static_cast< int >(val2);
4556 if (arg1) (arg1)->y = arg2;
4557
4558 resultobj = SWIG_Py_Void();
4559 return resultobj;
4560 fail:
4561 return NULL;
4562 }
4563
4564
4565 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4566 PyObject *resultobj = 0;
4567 wxSize *arg1 = (wxSize *) 0 ;
4568 int result;
4569 void *argp1 = 0 ;
4570 int res1 = 0 ;
4571 PyObject *swig_obj[1] ;
4572
4573 if (!args) SWIG_fail;
4574 swig_obj[0] = args;
4575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4576 if (!SWIG_IsOK(res1)) {
4577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4578 }
4579 arg1 = reinterpret_cast< wxSize * >(argp1);
4580 result = (int) ((arg1)->y);
4581 resultobj = SWIG_From_int(static_cast< int >(result));
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj = 0;
4590 int arg1 = (int) 0 ;
4591 int arg2 = (int) 0 ;
4592 wxSize *result = 0 ;
4593 int val1 ;
4594 int ecode1 = 0 ;
4595 int val2 ;
4596 int ecode2 = 0 ;
4597 PyObject * obj0 = 0 ;
4598 PyObject * obj1 = 0 ;
4599 char * kwnames[] = {
4600 (char *) "w",(char *) "h", NULL
4601 };
4602
4603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4604 if (obj0) {
4605 ecode1 = SWIG_AsVal_int(obj0, &val1);
4606 if (!SWIG_IsOK(ecode1)) {
4607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4608 }
4609 arg1 = static_cast< int >(val1);
4610 }
4611 if (obj1) {
4612 ecode2 = SWIG_AsVal_int(obj1, &val2);
4613 if (!SWIG_IsOK(ecode2)) {
4614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4615 }
4616 arg2 = static_cast< int >(val2);
4617 }
4618 {
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 result = (wxSize *)new wxSize(arg1,arg2);
4621 wxPyEndAllowThreads(__tstate);
4622 if (PyErr_Occurred()) SWIG_fail;
4623 }
4624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4625 return resultobj;
4626 fail:
4627 return NULL;
4628 }
4629
4630
4631 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4632 PyObject *resultobj = 0;
4633 wxSize *arg1 = (wxSize *) 0 ;
4634 void *argp1 = 0 ;
4635 int res1 = 0 ;
4636 PyObject *swig_obj[1] ;
4637
4638 if (!args) SWIG_fail;
4639 swig_obj[0] = args;
4640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4643 }
4644 arg1 = reinterpret_cast< wxSize * >(argp1);
4645 {
4646 PyThreadState* __tstate = wxPyBeginAllowThreads();
4647 delete arg1;
4648
4649 wxPyEndAllowThreads(__tstate);
4650 if (PyErr_Occurred()) SWIG_fail;
4651 }
4652 resultobj = SWIG_Py_Void();
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 wxSize *arg1 = (wxSize *) 0 ;
4662 PyObject *arg2 = (PyObject *) 0 ;
4663 bool result;
4664 void *argp1 = 0 ;
4665 int res1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "self",(char *) "other", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4674 if (!SWIG_IsOK(res1)) {
4675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4676 }
4677 arg1 = reinterpret_cast< wxSize * >(argp1);
4678 arg2 = obj1;
4679 {
4680 result = (bool)wxSize___eq__(arg1,arg2);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 {
4684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4685 }
4686 return resultobj;
4687 fail:
4688 return NULL;
4689 }
4690
4691
4692 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4693 PyObject *resultobj = 0;
4694 wxSize *arg1 = (wxSize *) 0 ;
4695 PyObject *arg2 = (PyObject *) 0 ;
4696 bool result;
4697 void *argp1 = 0 ;
4698 int res1 = 0 ;
4699 PyObject * obj0 = 0 ;
4700 PyObject * obj1 = 0 ;
4701 char * kwnames[] = {
4702 (char *) "self",(char *) "other", NULL
4703 };
4704
4705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4709 }
4710 arg1 = reinterpret_cast< wxSize * >(argp1);
4711 arg2 = obj1;
4712 {
4713 result = (bool)wxSize___ne__(arg1,arg2);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 {
4717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4718 }
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 wxSize *arg2 = 0 ;
4729 wxSize result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 wxSize temp2 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "sz", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 {
4746 arg2 = &temp2;
4747 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4748 }
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (arg1)->operator +((wxSize const &)*arg2);
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 wxSize *arg1 = (wxSize *) 0 ;
4765 wxSize *arg2 = 0 ;
4766 wxSize result;
4767 void *argp1 = 0 ;
4768 int res1 = 0 ;
4769 wxSize temp2 ;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 char * kwnames[] = {
4773 (char *) "self",(char *) "sz", NULL
4774 };
4775
4776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4778 if (!SWIG_IsOK(res1)) {
4779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4780 }
4781 arg1 = reinterpret_cast< wxSize * >(argp1);
4782 {
4783 arg2 = &temp2;
4784 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = (arg1)->operator -((wxSize const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4793 return resultobj;
4794 fail:
4795 return NULL;
4796 }
4797
4798
4799 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4800 PyObject *resultobj = 0;
4801 wxSize *arg1 = (wxSize *) 0 ;
4802 wxSize *arg2 = 0 ;
4803 void *argp1 = 0 ;
4804 int res1 = 0 ;
4805 wxSize temp2 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "self",(char *) "sz", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4814 if (!SWIG_IsOK(res1)) {
4815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4816 }
4817 arg1 = reinterpret_cast< wxSize * >(argp1);
4818 {
4819 arg2 = &temp2;
4820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 (arg1)->IncTo((wxSize const &)*arg2);
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 resultobj = SWIG_Py_Void();
4829 return resultobj;
4830 fail:
4831 return NULL;
4832 }
4833
4834
4835 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4836 PyObject *resultobj = 0;
4837 wxSize *arg1 = (wxSize *) 0 ;
4838 wxSize *arg2 = 0 ;
4839 void *argp1 = 0 ;
4840 int res1 = 0 ;
4841 wxSize temp2 ;
4842 PyObject * obj0 = 0 ;
4843 PyObject * obj1 = 0 ;
4844 char * kwnames[] = {
4845 (char *) "self",(char *) "sz", NULL
4846 };
4847
4848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4850 if (!SWIG_IsOK(res1)) {
4851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4852 }
4853 arg1 = reinterpret_cast< wxSize * >(argp1);
4854 {
4855 arg2 = &temp2;
4856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4857 }
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 (arg1)->DecTo((wxSize const &)*arg2);
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 resultobj = SWIG_Py_Void();
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4872 PyObject *resultobj = 0;
4873 wxSize *arg1 = (wxSize *) 0 ;
4874 int arg2 ;
4875 int arg3 ;
4876 void *argp1 = 0 ;
4877 int res1 = 0 ;
4878 int val2 ;
4879 int ecode2 = 0 ;
4880 int val3 ;
4881 int ecode3 = 0 ;
4882 PyObject * obj0 = 0 ;
4883 PyObject * obj1 = 0 ;
4884 PyObject * obj2 = 0 ;
4885 char * kwnames[] = {
4886 (char *) "self",(char *) "dx",(char *) "dy", NULL
4887 };
4888
4889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4891 if (!SWIG_IsOK(res1)) {
4892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4893 }
4894 arg1 = reinterpret_cast< wxSize * >(argp1);
4895 ecode2 = SWIG_AsVal_int(obj1, &val2);
4896 if (!SWIG_IsOK(ecode2)) {
4897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4898 }
4899 arg2 = static_cast< int >(val2);
4900 ecode3 = SWIG_AsVal_int(obj2, &val3);
4901 if (!SWIG_IsOK(ecode3)) {
4902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4903 }
4904 arg3 = static_cast< int >(val3);
4905 {
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 (arg1)->IncBy(arg2,arg3);
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 resultobj = SWIG_Py_Void();
4912 return resultobj;
4913 fail:
4914 return NULL;
4915 }
4916
4917
4918 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4919 PyObject *resultobj = 0;
4920 wxSize *arg1 = (wxSize *) 0 ;
4921 int arg2 ;
4922 int arg3 ;
4923 void *argp1 = 0 ;
4924 int res1 = 0 ;
4925 int val2 ;
4926 int ecode2 = 0 ;
4927 int val3 ;
4928 int ecode3 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 PyObject * obj1 = 0 ;
4931 PyObject * obj2 = 0 ;
4932 char * kwnames[] = {
4933 (char *) "self",(char *) "dx",(char *) "dy", NULL
4934 };
4935
4936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4938 if (!SWIG_IsOK(res1)) {
4939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4940 }
4941 arg1 = reinterpret_cast< wxSize * >(argp1);
4942 ecode2 = SWIG_AsVal_int(obj1, &val2);
4943 if (!SWIG_IsOK(ecode2)) {
4944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4945 }
4946 arg2 = static_cast< int >(val2);
4947 ecode3 = SWIG_AsVal_int(obj2, &val3);
4948 if (!SWIG_IsOK(ecode3)) {
4949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4950 }
4951 arg3 = static_cast< int >(val3);
4952 {
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 (arg1)->DecBy(arg2,arg3);
4955 wxPyEndAllowThreads(__tstate);
4956 if (PyErr_Occurred()) SWIG_fail;
4957 }
4958 resultobj = SWIG_Py_Void();
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj = 0;
4967 wxSize *arg1 = (wxSize *) 0 ;
4968 float arg2 ;
4969 float arg3 ;
4970 void *argp1 = 0 ;
4971 int res1 = 0 ;
4972 float val2 ;
4973 int ecode2 = 0 ;
4974 float val3 ;
4975 int ecode3 = 0 ;
4976 PyObject * obj0 = 0 ;
4977 PyObject * obj1 = 0 ;
4978 PyObject * obj2 = 0 ;
4979 char * kwnames[] = {
4980 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4981 };
4982
4983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4985 if (!SWIG_IsOK(res1)) {
4986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4987 }
4988 arg1 = reinterpret_cast< wxSize * >(argp1);
4989 ecode2 = SWIG_AsVal_float(obj1, &val2);
4990 if (!SWIG_IsOK(ecode2)) {
4991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4992 }
4993 arg2 = static_cast< float >(val2);
4994 ecode3 = SWIG_AsVal_float(obj2, &val3);
4995 if (!SWIG_IsOK(ecode3)) {
4996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4997 }
4998 arg3 = static_cast< float >(val3);
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 (arg1)->Scale(arg2,arg3);
5002 wxPyEndAllowThreads(__tstate);
5003 if (PyErr_Occurred()) SWIG_fail;
5004 }
5005 resultobj = SWIG_Py_Void();
5006 return resultobj;
5007 fail:
5008 return NULL;
5009 }
5010
5011
5012 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5013 PyObject *resultobj = 0;
5014 wxSize *arg1 = (wxSize *) 0 ;
5015 int arg2 ;
5016 int arg3 ;
5017 void *argp1 = 0 ;
5018 int res1 = 0 ;
5019 int val2 ;
5020 int ecode2 = 0 ;
5021 int val3 ;
5022 int ecode3 = 0 ;
5023 PyObject * obj0 = 0 ;
5024 PyObject * obj1 = 0 ;
5025 PyObject * obj2 = 0 ;
5026 char * kwnames[] = {
5027 (char *) "self",(char *) "w",(char *) "h", NULL
5028 };
5029
5030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5034 }
5035 arg1 = reinterpret_cast< wxSize * >(argp1);
5036 ecode2 = SWIG_AsVal_int(obj1, &val2);
5037 if (!SWIG_IsOK(ecode2)) {
5038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5039 }
5040 arg2 = static_cast< int >(val2);
5041 ecode3 = SWIG_AsVal_int(obj2, &val3);
5042 if (!SWIG_IsOK(ecode3)) {
5043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5044 }
5045 arg3 = static_cast< int >(val3);
5046 {
5047 PyThreadState* __tstate = wxPyBeginAllowThreads();
5048 (arg1)->Set(arg2,arg3);
5049 wxPyEndAllowThreads(__tstate);
5050 if (PyErr_Occurred()) SWIG_fail;
5051 }
5052 resultobj = SWIG_Py_Void();
5053 return resultobj;
5054 fail:
5055 return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5060 PyObject *resultobj = 0;
5061 wxSize *arg1 = (wxSize *) 0 ;
5062 int arg2 ;
5063 void *argp1 = 0 ;
5064 int res1 = 0 ;
5065 int val2 ;
5066 int ecode2 = 0 ;
5067 PyObject * obj0 = 0 ;
5068 PyObject * obj1 = 0 ;
5069 char * kwnames[] = {
5070 (char *) "self",(char *) "w", NULL
5071 };
5072
5073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5075 if (!SWIG_IsOK(res1)) {
5076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5077 }
5078 arg1 = reinterpret_cast< wxSize * >(argp1);
5079 ecode2 = SWIG_AsVal_int(obj1, &val2);
5080 if (!SWIG_IsOK(ecode2)) {
5081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5082 }
5083 arg2 = static_cast< int >(val2);
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 (arg1)->SetWidth(arg2);
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 resultobj = SWIG_Py_Void();
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5098 PyObject *resultobj = 0;
5099 wxSize *arg1 = (wxSize *) 0 ;
5100 int arg2 ;
5101 void *argp1 = 0 ;
5102 int res1 = 0 ;
5103 int val2 ;
5104 int ecode2 = 0 ;
5105 PyObject * obj0 = 0 ;
5106 PyObject * obj1 = 0 ;
5107 char * kwnames[] = {
5108 (char *) "self",(char *) "h", NULL
5109 };
5110
5111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5113 if (!SWIG_IsOK(res1)) {
5114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5115 }
5116 arg1 = reinterpret_cast< wxSize * >(argp1);
5117 ecode2 = SWIG_AsVal_int(obj1, &val2);
5118 if (!SWIG_IsOK(ecode2)) {
5119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5120 }
5121 arg2 = static_cast< int >(val2);
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 (arg1)->SetHeight(arg2);
5125 wxPyEndAllowThreads(__tstate);
5126 if (PyErr_Occurred()) SWIG_fail;
5127 }
5128 resultobj = SWIG_Py_Void();
5129 return resultobj;
5130 fail:
5131 return NULL;
5132 }
5133
5134
5135 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5136 PyObject *resultobj = 0;
5137 wxSize *arg1 = (wxSize *) 0 ;
5138 int result;
5139 void *argp1 = 0 ;
5140 int res1 = 0 ;
5141 PyObject *swig_obj[1] ;
5142
5143 if (!args) SWIG_fail;
5144 swig_obj[0] = args;
5145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5146 if (!SWIG_IsOK(res1)) {
5147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5148 }
5149 arg1 = reinterpret_cast< wxSize * >(argp1);
5150 {
5151 PyThreadState* __tstate = wxPyBeginAllowThreads();
5152 result = (int)((wxSize const *)arg1)->GetWidth();
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 resultobj = SWIG_From_int(static_cast< int >(result));
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5164 PyObject *resultobj = 0;
5165 wxSize *arg1 = (wxSize *) 0 ;
5166 int result;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 PyObject *swig_obj[1] ;
5170
5171 if (!args) SWIG_fail;
5172 swig_obj[0] = args;
5173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5176 }
5177 arg1 = reinterpret_cast< wxSize * >(argp1);
5178 {
5179 PyThreadState* __tstate = wxPyBeginAllowThreads();
5180 result = (int)((wxSize const *)arg1)->GetHeight();
5181 wxPyEndAllowThreads(__tstate);
5182 if (PyErr_Occurred()) SWIG_fail;
5183 }
5184 resultobj = SWIG_From_int(static_cast< int >(result));
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5192 PyObject *resultobj = 0;
5193 wxSize *arg1 = (wxSize *) 0 ;
5194 bool result;
5195 void *argp1 = 0 ;
5196 int res1 = 0 ;
5197 PyObject *swig_obj[1] ;
5198
5199 if (!args) SWIG_fail;
5200 swig_obj[0] = args;
5201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5202 if (!SWIG_IsOK(res1)) {
5203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5204 }
5205 arg1 = reinterpret_cast< wxSize * >(argp1);
5206 {
5207 PyThreadState* __tstate = wxPyBeginAllowThreads();
5208 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5209 wxPyEndAllowThreads(__tstate);
5210 if (PyErr_Occurred()) SWIG_fail;
5211 }
5212 {
5213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5214 }
5215 return resultobj;
5216 fail:
5217 return NULL;
5218 }
5219
5220
5221 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5222 PyObject *resultobj = 0;
5223 wxSize *arg1 = (wxSize *) 0 ;
5224 wxSize *arg2 = 0 ;
5225 void *argp1 = 0 ;
5226 int res1 = 0 ;
5227 wxSize temp2 ;
5228 PyObject * obj0 = 0 ;
5229 PyObject * obj1 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "self",(char *) "size", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5238 }
5239 arg1 = reinterpret_cast< wxSize * >(argp1);
5240 {
5241 arg2 = &temp2;
5242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5243 }
5244 {
5245 PyThreadState* __tstate = wxPyBeginAllowThreads();
5246 (arg1)->SetDefaults((wxSize const &)*arg2);
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 resultobj = SWIG_Py_Void();
5251 return resultobj;
5252 fail:
5253 return NULL;
5254 }
5255
5256
5257 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5258 PyObject *resultobj = 0;
5259 wxSize *arg1 = (wxSize *) 0 ;
5260 PyObject *result = 0 ;
5261 void *argp1 = 0 ;
5262 int res1 = 0 ;
5263 PyObject *swig_obj[1] ;
5264
5265 if (!args) SWIG_fail;
5266 swig_obj[0] = args;
5267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5268 if (!SWIG_IsOK(res1)) {
5269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5270 }
5271 arg1 = reinterpret_cast< wxSize * >(argp1);
5272 {
5273 PyThreadState* __tstate = wxPyBeginAllowThreads();
5274 result = (PyObject *)wxSize_Get(arg1);
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 resultobj = result;
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5286 PyObject *obj;
5287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5288 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5289 return SWIG_Py_Void();
5290 }
5291
5292 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5293 return SWIG_Python_InitShadowInstance(args);
5294 }
5295
5296 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5299 double arg2 ;
5300 void *argp1 = 0 ;
5301 int res1 = 0 ;
5302 double val2 ;
5303 int ecode2 = 0 ;
5304 PyObject *swig_obj[2] ;
5305
5306 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5308 if (!SWIG_IsOK(res1)) {
5309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5310 }
5311 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5312 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5313 if (!SWIG_IsOK(ecode2)) {
5314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5315 }
5316 arg2 = static_cast< double >(val2);
5317 if (arg1) (arg1)->x = arg2;
5318
5319 resultobj = SWIG_Py_Void();
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5327 PyObject *resultobj = 0;
5328 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5329 double result;
5330 void *argp1 = 0 ;
5331 int res1 = 0 ;
5332 PyObject *swig_obj[1] ;
5333
5334 if (!args) SWIG_fail;
5335 swig_obj[0] = args;
5336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5337 if (!SWIG_IsOK(res1)) {
5338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5339 }
5340 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5341 result = (double) ((arg1)->x);
5342 resultobj = SWIG_From_double(static_cast< double >(result));
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 double arg2 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 double val2 ;
5356 int ecode2 = 0 ;
5357 PyObject *swig_obj[2] ;
5358
5359 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5363 }
5364 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5365 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5366 if (!SWIG_IsOK(ecode2)) {
5367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5368 }
5369 arg2 = static_cast< double >(val2);
5370 if (arg1) (arg1)->y = arg2;
5371
5372 resultobj = SWIG_Py_Void();
5373 return resultobj;
5374 fail:
5375 return NULL;
5376 }
5377
5378
5379 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5380 PyObject *resultobj = 0;
5381 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5382 double result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject *swig_obj[1] ;
5386
5387 if (!args) SWIG_fail;
5388 swig_obj[0] = args;
5389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5392 }
5393 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5394 result = (double) ((arg1)->y);
5395 resultobj = SWIG_From_double(static_cast< double >(result));
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5403 PyObject *resultobj = 0;
5404 double arg1 = (double) 0.0 ;
5405 double arg2 = (double) 0.0 ;
5406 wxRealPoint *result = 0 ;
5407 double val1 ;
5408 int ecode1 = 0 ;
5409 double val2 ;
5410 int ecode2 = 0 ;
5411 PyObject * obj0 = 0 ;
5412 PyObject * obj1 = 0 ;
5413 char * kwnames[] = {
5414 (char *) "x",(char *) "y", NULL
5415 };
5416
5417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5418 if (obj0) {
5419 ecode1 = SWIG_AsVal_double(obj0, &val1);
5420 if (!SWIG_IsOK(ecode1)) {
5421 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5422 }
5423 arg1 = static_cast< double >(val1);
5424 }
5425 if (obj1) {
5426 ecode2 = SWIG_AsVal_double(obj1, &val2);
5427 if (!SWIG_IsOK(ecode2)) {
5428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5429 }
5430 arg2 = static_cast< double >(val2);
5431 }
5432 {
5433 PyThreadState* __tstate = wxPyBeginAllowThreads();
5434 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5435 wxPyEndAllowThreads(__tstate);
5436 if (PyErr_Occurred()) SWIG_fail;
5437 }
5438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5446 PyObject *resultobj = 0;
5447 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5448 void *argp1 = 0 ;
5449 int res1 = 0 ;
5450 PyObject *swig_obj[1] ;
5451
5452 if (!args) SWIG_fail;
5453 swig_obj[0] = args;
5454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5455 if (!SWIG_IsOK(res1)) {
5456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5457 }
5458 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5459 {
5460 PyThreadState* __tstate = wxPyBeginAllowThreads();
5461 delete arg1;
5462
5463 wxPyEndAllowThreads(__tstate);
5464 if (PyErr_Occurred()) SWIG_fail;
5465 }
5466 resultobj = SWIG_Py_Void();
5467 return resultobj;
5468 fail:
5469 return NULL;
5470 }
5471
5472
5473 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5474 PyObject *resultobj = 0;
5475 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5476 PyObject *arg2 = (PyObject *) 0 ;
5477 bool result;
5478 void *argp1 = 0 ;
5479 int res1 = 0 ;
5480 PyObject * obj0 = 0 ;
5481 PyObject * obj1 = 0 ;
5482 char * kwnames[] = {
5483 (char *) "self",(char *) "other", NULL
5484 };
5485
5486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5490 }
5491 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5492 arg2 = obj1;
5493 {
5494 result = (bool)wxRealPoint___eq__(arg1,arg2);
5495 if (PyErr_Occurred()) SWIG_fail;
5496 }
5497 {
5498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5499 }
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj = 0;
5508 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5509 PyObject *arg2 = (PyObject *) 0 ;
5510 bool result;
5511 void *argp1 = 0 ;
5512 int res1 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 char * kwnames[] = {
5516 (char *) "self",(char *) "other", NULL
5517 };
5518
5519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5521 if (!SWIG_IsOK(res1)) {
5522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5523 }
5524 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5525 arg2 = obj1;
5526 {
5527 result = (bool)wxRealPoint___ne__(arg1,arg2);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj = 0;
5541 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5542 wxRealPoint *arg2 = 0 ;
5543 wxRealPoint result;
5544 void *argp1 = 0 ;
5545 int res1 = 0 ;
5546 wxRealPoint temp2 ;
5547 PyObject * obj0 = 0 ;
5548 PyObject * obj1 = 0 ;
5549 char * kwnames[] = {
5550 (char *) "self",(char *) "pt", NULL
5551 };
5552
5553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5555 if (!SWIG_IsOK(res1)) {
5556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5557 }
5558 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5559 {
5560 arg2 = &temp2;
5561 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5562 }
5563 {
5564 PyThreadState* __tstate = wxPyBeginAllowThreads();
5565 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5570 return resultobj;
5571 fail:
5572 return NULL;
5573 }
5574
5575
5576 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5577 PyObject *resultobj = 0;
5578 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5579 wxRealPoint *arg2 = 0 ;
5580 wxRealPoint result;
5581 void *argp1 = 0 ;
5582 int res1 = 0 ;
5583 wxRealPoint temp2 ;
5584 PyObject * obj0 = 0 ;
5585 PyObject * obj1 = 0 ;
5586 char * kwnames[] = {
5587 (char *) "self",(char *) "pt", NULL
5588 };
5589
5590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5592 if (!SWIG_IsOK(res1)) {
5593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5594 }
5595 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5596 {
5597 arg2 = &temp2;
5598 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5599 }
5600 {
5601 PyThreadState* __tstate = wxPyBeginAllowThreads();
5602 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5603 wxPyEndAllowThreads(__tstate);
5604 if (PyErr_Occurred()) SWIG_fail;
5605 }
5606 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj = 0;
5615 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5616 double arg2 ;
5617 double arg3 ;
5618 void *argp1 = 0 ;
5619 int res1 = 0 ;
5620 double val2 ;
5621 int ecode2 = 0 ;
5622 double val3 ;
5623 int ecode3 = 0 ;
5624 PyObject * obj0 = 0 ;
5625 PyObject * obj1 = 0 ;
5626 PyObject * obj2 = 0 ;
5627 char * kwnames[] = {
5628 (char *) "self",(char *) "x",(char *) "y", NULL
5629 };
5630
5631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5633 if (!SWIG_IsOK(res1)) {
5634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5635 }
5636 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5637 ecode2 = SWIG_AsVal_double(obj1, &val2);
5638 if (!SWIG_IsOK(ecode2)) {
5639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5640 }
5641 arg2 = static_cast< double >(val2);
5642 ecode3 = SWIG_AsVal_double(obj2, &val3);
5643 if (!SWIG_IsOK(ecode3)) {
5644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5645 }
5646 arg3 = static_cast< double >(val3);
5647 {
5648 PyThreadState* __tstate = wxPyBeginAllowThreads();
5649 wxRealPoint_Set(arg1,arg2,arg3);
5650 wxPyEndAllowThreads(__tstate);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 resultobj = SWIG_Py_Void();
5654 return resultobj;
5655 fail:
5656 return NULL;
5657 }
5658
5659
5660 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5661 PyObject *resultobj = 0;
5662 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5663 PyObject *result = 0 ;
5664 void *argp1 = 0 ;
5665 int res1 = 0 ;
5666 PyObject *swig_obj[1] ;
5667
5668 if (!args) SWIG_fail;
5669 swig_obj[0] = args;
5670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5671 if (!SWIG_IsOK(res1)) {
5672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5673 }
5674 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5675 {
5676 PyThreadState* __tstate = wxPyBeginAllowThreads();
5677 result = (PyObject *)wxRealPoint_Get(arg1);
5678 wxPyEndAllowThreads(__tstate);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 resultobj = result;
5682 return resultobj;
5683 fail:
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689 PyObject *obj;
5690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5691 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5692 return SWIG_Py_Void();
5693 }
5694
5695 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5696 return SWIG_Python_InitShadowInstance(args);
5697 }
5698
5699 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5700 PyObject *resultobj = 0;
5701 wxPoint *arg1 = (wxPoint *) 0 ;
5702 int arg2 ;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 int val2 ;
5706 int ecode2 = 0 ;
5707 PyObject *swig_obj[2] ;
5708
5709 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5711 if (!SWIG_IsOK(res1)) {
5712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5713 }
5714 arg1 = reinterpret_cast< wxPoint * >(argp1);
5715 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5716 if (!SWIG_IsOK(ecode2)) {
5717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5718 }
5719 arg2 = static_cast< int >(val2);
5720 if (arg1) (arg1)->x = arg2;
5721
5722 resultobj = SWIG_Py_Void();
5723 return resultobj;
5724 fail:
5725 return NULL;
5726 }
5727
5728
5729 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *resultobj = 0;
5731 wxPoint *arg1 = (wxPoint *) 0 ;
5732 int result;
5733 void *argp1 = 0 ;
5734 int res1 = 0 ;
5735 PyObject *swig_obj[1] ;
5736
5737 if (!args) SWIG_fail;
5738 swig_obj[0] = args;
5739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5740 if (!SWIG_IsOK(res1)) {
5741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5742 }
5743 arg1 = reinterpret_cast< wxPoint * >(argp1);
5744 result = (int) ((arg1)->x);
5745 resultobj = SWIG_From_int(static_cast< int >(result));
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 int arg2 ;
5756 void *argp1 = 0 ;
5757 int res1 = 0 ;
5758 int val2 ;
5759 int ecode2 = 0 ;
5760 PyObject *swig_obj[2] ;
5761
5762 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5764 if (!SWIG_IsOK(res1)) {
5765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5766 }
5767 arg1 = reinterpret_cast< wxPoint * >(argp1);
5768 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5769 if (!SWIG_IsOK(ecode2)) {
5770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5771 }
5772 arg2 = static_cast< int >(val2);
5773 if (arg1) (arg1)->y = arg2;
5774
5775 resultobj = SWIG_Py_Void();
5776 return resultobj;
5777 fail:
5778 return NULL;
5779 }
5780
5781
5782 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5783 PyObject *resultobj = 0;
5784 wxPoint *arg1 = (wxPoint *) 0 ;
5785 int result;
5786 void *argp1 = 0 ;
5787 int res1 = 0 ;
5788 PyObject *swig_obj[1] ;
5789
5790 if (!args) SWIG_fail;
5791 swig_obj[0] = args;
5792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5793 if (!SWIG_IsOK(res1)) {
5794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5795 }
5796 arg1 = reinterpret_cast< wxPoint * >(argp1);
5797 result = (int) ((arg1)->y);
5798 resultobj = SWIG_From_int(static_cast< int >(result));
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj = 0;
5807 int arg1 = (int) 0 ;
5808 int arg2 = (int) 0 ;
5809 wxPoint *result = 0 ;
5810 int val1 ;
5811 int ecode1 = 0 ;
5812 int val2 ;
5813 int ecode2 = 0 ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 char * kwnames[] = {
5817 (char *) "x",(char *) "y", NULL
5818 };
5819
5820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5821 if (obj0) {
5822 ecode1 = SWIG_AsVal_int(obj0, &val1);
5823 if (!SWIG_IsOK(ecode1)) {
5824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5825 }
5826 arg1 = static_cast< int >(val1);
5827 }
5828 if (obj1) {
5829 ecode2 = SWIG_AsVal_int(obj1, &val2);
5830 if (!SWIG_IsOK(ecode2)) {
5831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5832 }
5833 arg2 = static_cast< int >(val2);
5834 }
5835 {
5836 PyThreadState* __tstate = wxPyBeginAllowThreads();
5837 result = (wxPoint *)new wxPoint(arg1,arg2);
5838 wxPyEndAllowThreads(__tstate);
5839 if (PyErr_Occurred()) SWIG_fail;
5840 }
5841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5842 return resultobj;
5843 fail:
5844 return NULL;
5845 }
5846
5847
5848 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5849 PyObject *resultobj = 0;
5850 wxPoint *arg1 = (wxPoint *) 0 ;
5851 void *argp1 = 0 ;
5852 int res1 = 0 ;
5853 PyObject *swig_obj[1] ;
5854
5855 if (!args) SWIG_fail;
5856 swig_obj[0] = args;
5857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5858 if (!SWIG_IsOK(res1)) {
5859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5860 }
5861 arg1 = reinterpret_cast< wxPoint * >(argp1);
5862 {
5863 PyThreadState* __tstate = wxPyBeginAllowThreads();
5864 delete arg1;
5865
5866 wxPyEndAllowThreads(__tstate);
5867 if (PyErr_Occurred()) SWIG_fail;
5868 }
5869 resultobj = SWIG_Py_Void();
5870 return resultobj;
5871 fail:
5872 return NULL;
5873 }
5874
5875
5876 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5877 PyObject *resultobj = 0;
5878 wxPoint *arg1 = (wxPoint *) 0 ;
5879 PyObject *arg2 = (PyObject *) 0 ;
5880 bool result;
5881 void *argp1 = 0 ;
5882 int res1 = 0 ;
5883 PyObject * obj0 = 0 ;
5884 PyObject * obj1 = 0 ;
5885 char * kwnames[] = {
5886 (char *) "self",(char *) "other", NULL
5887 };
5888
5889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5891 if (!SWIG_IsOK(res1)) {
5892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5893 }
5894 arg1 = reinterpret_cast< wxPoint * >(argp1);
5895 arg2 = obj1;
5896 {
5897 result = (bool)wxPoint___eq__(arg1,arg2);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5902 }
5903 return resultobj;
5904 fail:
5905 return NULL;
5906 }
5907
5908
5909 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5910 PyObject *resultobj = 0;
5911 wxPoint *arg1 = (wxPoint *) 0 ;
5912 PyObject *arg2 = (PyObject *) 0 ;
5913 bool result;
5914 void *argp1 = 0 ;
5915 int res1 = 0 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 char * kwnames[] = {
5919 (char *) "self",(char *) "other", NULL
5920 };
5921
5922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5924 if (!SWIG_IsOK(res1)) {
5925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5926 }
5927 arg1 = reinterpret_cast< wxPoint * >(argp1);
5928 arg2 = obj1;
5929 {
5930 result = (bool)wxPoint___ne__(arg1,arg2);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 {
5934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5935 }
5936 return resultobj;
5937 fail:
5938 return NULL;
5939 }
5940
5941
5942 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj = 0;
5944 wxPoint *arg1 = (wxPoint *) 0 ;
5945 wxPoint *arg2 = 0 ;
5946 wxPoint result;
5947 void *argp1 = 0 ;
5948 int res1 = 0 ;
5949 wxPoint temp2 ;
5950 PyObject * obj0 = 0 ;
5951 PyObject * obj1 = 0 ;
5952 char * kwnames[] = {
5953 (char *) "self",(char *) "pt", NULL
5954 };
5955
5956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5958 if (!SWIG_IsOK(res1)) {
5959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5960 }
5961 arg1 = reinterpret_cast< wxPoint * >(argp1);
5962 {
5963 arg2 = &temp2;
5964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5965 }
5966 {
5967 PyThreadState* __tstate = wxPyBeginAllowThreads();
5968 result = (arg1)->operator +((wxPoint const &)*arg2);
5969 wxPyEndAllowThreads(__tstate);
5970 if (PyErr_Occurred()) SWIG_fail;
5971 }
5972 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj = 0;
5981 wxPoint *arg1 = (wxPoint *) 0 ;
5982 wxPoint *arg2 = 0 ;
5983 wxPoint result;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 wxPoint temp2 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 char * kwnames[] = {
5990 (char *) "self",(char *) "pt", NULL
5991 };
5992
5993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5995 if (!SWIG_IsOK(res1)) {
5996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5997 }
5998 arg1 = reinterpret_cast< wxPoint * >(argp1);
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (arg1)->operator -((wxPoint const &)*arg2);
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj = 0;
6018 wxPoint *arg1 = (wxPoint *) 0 ;
6019 wxPoint *arg2 = 0 ;
6020 wxPoint *result = 0 ;
6021 void *argp1 = 0 ;
6022 int res1 = 0 ;
6023 wxPoint temp2 ;
6024 PyObject * obj0 = 0 ;
6025 PyObject * obj1 = 0 ;
6026 char * kwnames[] = {
6027 (char *) "self",(char *) "pt", NULL
6028 };
6029
6030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6032 if (!SWIG_IsOK(res1)) {
6033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6034 }
6035 arg1 = reinterpret_cast< wxPoint * >(argp1);
6036 {
6037 arg2 = &temp2;
6038 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6039 }
6040 {
6041 PyThreadState* __tstate = wxPyBeginAllowThreads();
6042 {
6043 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6044 result = (wxPoint *) &_result_ref;
6045 }
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6057 PyObject *resultobj = 0;
6058 wxPoint *arg1 = (wxPoint *) 0 ;
6059 wxPoint *arg2 = 0 ;
6060 wxPoint *result = 0 ;
6061 void *argp1 = 0 ;
6062 int res1 = 0 ;
6063 wxPoint temp2 ;
6064 PyObject * obj0 = 0 ;
6065 PyObject * obj1 = 0 ;
6066 char * kwnames[] = {
6067 (char *) "self",(char *) "pt", NULL
6068 };
6069
6070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6072 if (!SWIG_IsOK(res1)) {
6073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6074 }
6075 arg1 = reinterpret_cast< wxPoint * >(argp1);
6076 {
6077 arg2 = &temp2;
6078 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6079 }
6080 {
6081 PyThreadState* __tstate = wxPyBeginAllowThreads();
6082 {
6083 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6084 result = (wxPoint *) &_result_ref;
6085 }
6086 wxPyEndAllowThreads(__tstate);
6087 if (PyErr_Occurred()) SWIG_fail;
6088 }
6089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6090 return resultobj;
6091 fail:
6092 return NULL;
6093 }
6094
6095
6096 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6097 PyObject *resultobj = 0;
6098 wxPoint *arg1 = (wxPoint *) 0 ;
6099 long arg2 ;
6100 long arg3 ;
6101 void *argp1 = 0 ;
6102 int res1 = 0 ;
6103 long val2 ;
6104 int ecode2 = 0 ;
6105 long val3 ;
6106 int ecode3 = 0 ;
6107 PyObject * obj0 = 0 ;
6108 PyObject * obj1 = 0 ;
6109 PyObject * obj2 = 0 ;
6110 char * kwnames[] = {
6111 (char *) "self",(char *) "x",(char *) "y", NULL
6112 };
6113
6114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6116 if (!SWIG_IsOK(res1)) {
6117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6118 }
6119 arg1 = reinterpret_cast< wxPoint * >(argp1);
6120 ecode2 = SWIG_AsVal_long(obj1, &val2);
6121 if (!SWIG_IsOK(ecode2)) {
6122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6123 }
6124 arg2 = static_cast< long >(val2);
6125 ecode3 = SWIG_AsVal_long(obj2, &val3);
6126 if (!SWIG_IsOK(ecode3)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6128 }
6129 arg3 = static_cast< long >(val3);
6130 {
6131 PyThreadState* __tstate = wxPyBeginAllowThreads();
6132 wxPoint_Set(arg1,arg2,arg3);
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 resultobj = SWIG_Py_Void();
6137 return resultobj;
6138 fail:
6139 return NULL;
6140 }
6141
6142
6143 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6144 PyObject *resultobj = 0;
6145 wxPoint *arg1 = (wxPoint *) 0 ;
6146 PyObject *result = 0 ;
6147 void *argp1 = 0 ;
6148 int res1 = 0 ;
6149 PyObject *swig_obj[1] ;
6150
6151 if (!args) SWIG_fail;
6152 swig_obj[0] = args;
6153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6154 if (!SWIG_IsOK(res1)) {
6155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6156 }
6157 arg1 = reinterpret_cast< wxPoint * >(argp1);
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (PyObject *)wxPoint_Get(arg1);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = result;
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6172 PyObject *obj;
6173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6174 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6175 return SWIG_Py_Void();
6176 }
6177
6178 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6179 return SWIG_Python_InitShadowInstance(args);
6180 }
6181
6182 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj = 0;
6184 int arg1 = (int) 0 ;
6185 int arg2 = (int) 0 ;
6186 int arg3 = (int) 0 ;
6187 int arg4 = (int) 0 ;
6188 wxRect *result = 0 ;
6189 int val1 ;
6190 int ecode1 = 0 ;
6191 int val2 ;
6192 int ecode2 = 0 ;
6193 int val3 ;
6194 int ecode3 = 0 ;
6195 int val4 ;
6196 int ecode4 = 0 ;
6197 PyObject * obj0 = 0 ;
6198 PyObject * obj1 = 0 ;
6199 PyObject * obj2 = 0 ;
6200 PyObject * obj3 = 0 ;
6201 char * kwnames[] = {
6202 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6203 };
6204
6205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6206 if (obj0) {
6207 ecode1 = SWIG_AsVal_int(obj0, &val1);
6208 if (!SWIG_IsOK(ecode1)) {
6209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6210 }
6211 arg1 = static_cast< int >(val1);
6212 }
6213 if (obj1) {
6214 ecode2 = SWIG_AsVal_int(obj1, &val2);
6215 if (!SWIG_IsOK(ecode2)) {
6216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6217 }
6218 arg2 = static_cast< int >(val2);
6219 }
6220 if (obj2) {
6221 ecode3 = SWIG_AsVal_int(obj2, &val3);
6222 if (!SWIG_IsOK(ecode3)) {
6223 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6224 }
6225 arg3 = static_cast< int >(val3);
6226 }
6227 if (obj3) {
6228 ecode4 = SWIG_AsVal_int(obj3, &val4);
6229 if (!SWIG_IsOK(ecode4)) {
6230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6231 }
6232 arg4 = static_cast< int >(val4);
6233 }
6234 {
6235 PyThreadState* __tstate = wxPyBeginAllowThreads();
6236 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6237 wxPyEndAllowThreads(__tstate);
6238 if (PyErr_Occurred()) SWIG_fail;
6239 }
6240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6241 return resultobj;
6242 fail:
6243 return NULL;
6244 }
6245
6246
6247 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6248 PyObject *resultobj = 0;
6249 wxPoint *arg1 = 0 ;
6250 wxPoint *arg2 = 0 ;
6251 wxRect *result = 0 ;
6252 wxPoint temp1 ;
6253 wxPoint temp2 ;
6254 PyObject * obj0 = 0 ;
6255 PyObject * obj1 = 0 ;
6256 char * kwnames[] = {
6257 (char *) "topLeft",(char *) "bottomRight", NULL
6258 };
6259
6260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6261 {
6262 arg1 = &temp1;
6263 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6264 }
6265 {
6266 arg2 = &temp2;
6267 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6268 }
6269 {
6270 PyThreadState* __tstate = wxPyBeginAllowThreads();
6271 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6272 wxPyEndAllowThreads(__tstate);
6273 if (PyErr_Occurred()) SWIG_fail;
6274 }
6275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6276 return resultobj;
6277 fail:
6278 return NULL;
6279 }
6280
6281
6282 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6283 PyObject *resultobj = 0;
6284 wxPoint *arg1 = 0 ;
6285 wxSize *arg2 = 0 ;
6286 wxRect *result = 0 ;
6287 wxPoint temp1 ;
6288 wxSize temp2 ;
6289 PyObject * obj0 = 0 ;
6290 PyObject * obj1 = 0 ;
6291 char * kwnames[] = {
6292 (char *) "pos",(char *) "size", NULL
6293 };
6294
6295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6296 {
6297 arg1 = &temp1;
6298 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6299 }
6300 {
6301 arg2 = &temp2;
6302 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6303 }
6304 {
6305 PyThreadState* __tstate = wxPyBeginAllowThreads();
6306 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6307 wxPyEndAllowThreads(__tstate);
6308 if (PyErr_Occurred()) SWIG_fail;
6309 }
6310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6311 return resultobj;
6312 fail:
6313 return NULL;
6314 }
6315
6316
6317 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj = 0;
6319 wxSize *arg1 = 0 ;
6320 wxRect *result = 0 ;
6321 wxSize temp1 ;
6322 PyObject * obj0 = 0 ;
6323 char * kwnames[] = {
6324 (char *) "size", NULL
6325 };
6326
6327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6328 {
6329 arg1 = &temp1;
6330 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6331 }
6332 {
6333 PyThreadState* __tstate = wxPyBeginAllowThreads();
6334 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6335 wxPyEndAllowThreads(__tstate);
6336 if (PyErr_Occurred()) SWIG_fail;
6337 }
6338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6339 return resultobj;
6340 fail:
6341 return NULL;
6342 }
6343
6344
6345 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6346 PyObject *resultobj = 0;
6347 wxRect *arg1 = (wxRect *) 0 ;
6348 void *argp1 = 0 ;
6349 int res1 = 0 ;
6350 PyObject *swig_obj[1] ;
6351
6352 if (!args) SWIG_fail;
6353 swig_obj[0] = args;
6354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6355 if (!SWIG_IsOK(res1)) {
6356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6357 }
6358 arg1 = reinterpret_cast< wxRect * >(argp1);
6359 {
6360 PyThreadState* __tstate = wxPyBeginAllowThreads();
6361 delete arg1;
6362
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_Py_Void();
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6374 PyObject *resultobj = 0;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 int result;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 PyObject *swig_obj[1] ;
6380
6381 if (!args) SWIG_fail;
6382 swig_obj[0] = args;
6383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6384 if (!SWIG_IsOK(res1)) {
6385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6386 }
6387 arg1 = reinterpret_cast< wxRect * >(argp1);
6388 {
6389 PyThreadState* __tstate = wxPyBeginAllowThreads();
6390 result = (int)((wxRect const *)arg1)->GetX();
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 resultobj = SWIG_From_int(static_cast< int >(result));
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj = 0;
6403 wxRect *arg1 = (wxRect *) 0 ;
6404 int arg2 ;
6405 void *argp1 = 0 ;
6406 int res1 = 0 ;
6407 int val2 ;
6408 int ecode2 = 0 ;
6409 PyObject * obj0 = 0 ;
6410 PyObject * obj1 = 0 ;
6411 char * kwnames[] = {
6412 (char *) "self",(char *) "x", NULL
6413 };
6414
6415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6417 if (!SWIG_IsOK(res1)) {
6418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6419 }
6420 arg1 = reinterpret_cast< wxRect * >(argp1);
6421 ecode2 = SWIG_AsVal_int(obj1, &val2);
6422 if (!SWIG_IsOK(ecode2)) {
6423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6424 }
6425 arg2 = static_cast< int >(val2);
6426 {
6427 PyThreadState* __tstate = wxPyBeginAllowThreads();
6428 (arg1)->SetX(arg2);
6429 wxPyEndAllowThreads(__tstate);
6430 if (PyErr_Occurred()) SWIG_fail;
6431 }
6432 resultobj = SWIG_Py_Void();
6433 return resultobj;
6434 fail:
6435 return NULL;
6436 }
6437
6438
6439 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6440 PyObject *resultobj = 0;
6441 wxRect *arg1 = (wxRect *) 0 ;
6442 int result;
6443 void *argp1 = 0 ;
6444 int res1 = 0 ;
6445 PyObject *swig_obj[1] ;
6446
6447 if (!args) SWIG_fail;
6448 swig_obj[0] = args;
6449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6450 if (!SWIG_IsOK(res1)) {
6451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6452 }
6453 arg1 = reinterpret_cast< wxRect * >(argp1);
6454 {
6455 PyThreadState* __tstate = wxPyBeginAllowThreads();
6456 result = (int)(arg1)->GetY();
6457 wxPyEndAllowThreads(__tstate);
6458 if (PyErr_Occurred()) SWIG_fail;
6459 }
6460 resultobj = SWIG_From_int(static_cast< int >(result));
6461 return resultobj;
6462 fail:
6463 return NULL;
6464 }
6465
6466
6467 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6468 PyObject *resultobj = 0;
6469 wxRect *arg1 = (wxRect *) 0 ;
6470 int arg2 ;
6471 void *argp1 = 0 ;
6472 int res1 = 0 ;
6473 int val2 ;
6474 int ecode2 = 0 ;
6475 PyObject * obj0 = 0 ;
6476 PyObject * obj1 = 0 ;
6477 char * kwnames[] = {
6478 (char *) "self",(char *) "y", NULL
6479 };
6480
6481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6483 if (!SWIG_IsOK(res1)) {
6484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6485 }
6486 arg1 = reinterpret_cast< wxRect * >(argp1);
6487 ecode2 = SWIG_AsVal_int(obj1, &val2);
6488 if (!SWIG_IsOK(ecode2)) {
6489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6490 }
6491 arg2 = static_cast< int >(val2);
6492 {
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 (arg1)->SetY(arg2);
6495 wxPyEndAllowThreads(__tstate);
6496 if (PyErr_Occurred()) SWIG_fail;
6497 }
6498 resultobj = SWIG_Py_Void();
6499 return resultobj;
6500 fail:
6501 return NULL;
6502 }
6503
6504
6505 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6506 PyObject *resultobj = 0;
6507 wxRect *arg1 = (wxRect *) 0 ;
6508 int result;
6509 void *argp1 = 0 ;
6510 int res1 = 0 ;
6511 PyObject *swig_obj[1] ;
6512
6513 if (!args) SWIG_fail;
6514 swig_obj[0] = args;
6515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6516 if (!SWIG_IsOK(res1)) {
6517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6518 }
6519 arg1 = reinterpret_cast< wxRect * >(argp1);
6520 {
6521 PyThreadState* __tstate = wxPyBeginAllowThreads();
6522 result = (int)((wxRect const *)arg1)->GetWidth();
6523 wxPyEndAllowThreads(__tstate);
6524 if (PyErr_Occurred()) SWIG_fail;
6525 }
6526 resultobj = SWIG_From_int(static_cast< int >(result));
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj = 0;
6535 wxRect *arg1 = (wxRect *) 0 ;
6536 int arg2 ;
6537 void *argp1 = 0 ;
6538 int res1 = 0 ;
6539 int val2 ;
6540 int ecode2 = 0 ;
6541 PyObject * obj0 = 0 ;
6542 PyObject * obj1 = 0 ;
6543 char * kwnames[] = {
6544 (char *) "self",(char *) "w", NULL
6545 };
6546
6547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6551 }
6552 arg1 = reinterpret_cast< wxRect * >(argp1);
6553 ecode2 = SWIG_AsVal_int(obj1, &val2);
6554 if (!SWIG_IsOK(ecode2)) {
6555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6556 }
6557 arg2 = static_cast< int >(val2);
6558 {
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 (arg1)->SetWidth(arg2);
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 resultobj = SWIG_Py_Void();
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6572 PyObject *resultobj = 0;
6573 wxRect *arg1 = (wxRect *) 0 ;
6574 int result;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 PyObject *swig_obj[1] ;
6578
6579 if (!args) SWIG_fail;
6580 swig_obj[0] = args;
6581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6582 if (!SWIG_IsOK(res1)) {
6583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6584 }
6585 arg1 = reinterpret_cast< wxRect * >(argp1);
6586 {
6587 PyThreadState* __tstate = wxPyBeginAllowThreads();
6588 result = (int)((wxRect const *)arg1)->GetHeight();
6589 wxPyEndAllowThreads(__tstate);
6590 if (PyErr_Occurred()) SWIG_fail;
6591 }
6592 resultobj = SWIG_From_int(static_cast< int >(result));
6593 return resultobj;
6594 fail:
6595 return NULL;
6596 }
6597
6598
6599 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6600 PyObject *resultobj = 0;
6601 wxRect *arg1 = (wxRect *) 0 ;
6602 int arg2 ;
6603 void *argp1 = 0 ;
6604 int res1 = 0 ;
6605 int val2 ;
6606 int ecode2 = 0 ;
6607 PyObject * obj0 = 0 ;
6608 PyObject * obj1 = 0 ;
6609 char * kwnames[] = {
6610 (char *) "self",(char *) "h", NULL
6611 };
6612
6613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6615 if (!SWIG_IsOK(res1)) {
6616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6617 }
6618 arg1 = reinterpret_cast< wxRect * >(argp1);
6619 ecode2 = SWIG_AsVal_int(obj1, &val2);
6620 if (!SWIG_IsOK(ecode2)) {
6621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6622 }
6623 arg2 = static_cast< int >(val2);
6624 {
6625 PyThreadState* __tstate = wxPyBeginAllowThreads();
6626 (arg1)->SetHeight(arg2);
6627 wxPyEndAllowThreads(__tstate);
6628 if (PyErr_Occurred()) SWIG_fail;
6629 }
6630 resultobj = SWIG_Py_Void();
6631 return resultobj;
6632 fail:
6633 return NULL;
6634 }
6635
6636
6637 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6638 PyObject *resultobj = 0;
6639 wxRect *arg1 = (wxRect *) 0 ;
6640 wxPoint result;
6641 void *argp1 = 0 ;
6642 int res1 = 0 ;
6643 PyObject *swig_obj[1] ;
6644
6645 if (!args) SWIG_fail;
6646 swig_obj[0] = args;
6647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 PyThreadState* __tstate = wxPyBeginAllowThreads();
6654 result = ((wxRect const *)arg1)->GetPosition();
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6666 PyObject *resultobj = 0;
6667 wxRect *arg1 = (wxRect *) 0 ;
6668 wxPoint *arg2 = 0 ;
6669 void *argp1 = 0 ;
6670 int res1 = 0 ;
6671 wxPoint temp2 ;
6672 PyObject * obj0 = 0 ;
6673 PyObject * obj1 = 0 ;
6674 char * kwnames[] = {
6675 (char *) "self",(char *) "p", NULL
6676 };
6677
6678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6682 }
6683 arg1 = reinterpret_cast< wxRect * >(argp1);
6684 {
6685 arg2 = &temp2;
6686 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6687 }
6688 {
6689 PyThreadState* __tstate = wxPyBeginAllowThreads();
6690 (arg1)->SetPosition((wxPoint const &)*arg2);
6691 wxPyEndAllowThreads(__tstate);
6692 if (PyErr_Occurred()) SWIG_fail;
6693 }
6694 resultobj = SWIG_Py_Void();
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6702 PyObject *resultobj = 0;
6703 wxRect *arg1 = (wxRect *) 0 ;
6704 wxSize result;
6705 void *argp1 = 0 ;
6706 int res1 = 0 ;
6707 PyObject *swig_obj[1] ;
6708
6709 if (!args) SWIG_fail;
6710 swig_obj[0] = args;
6711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6712 if (!SWIG_IsOK(res1)) {
6713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6714 }
6715 arg1 = reinterpret_cast< wxRect * >(argp1);
6716 {
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 result = ((wxRect const *)arg1)->GetSize();
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6730 PyObject *resultobj = 0;
6731 wxRect *arg1 = (wxRect *) 0 ;
6732 wxSize *arg2 = 0 ;
6733 void *argp1 = 0 ;
6734 int res1 = 0 ;
6735 wxSize temp2 ;
6736 PyObject * obj0 = 0 ;
6737 PyObject * obj1 = 0 ;
6738 char * kwnames[] = {
6739 (char *) "self",(char *) "s", NULL
6740 };
6741
6742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6744 if (!SWIG_IsOK(res1)) {
6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6746 }
6747 arg1 = reinterpret_cast< wxRect * >(argp1);
6748 {
6749 arg2 = &temp2;
6750 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6751 }
6752 {
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 (arg1)->SetSize((wxSize const &)*arg2);
6755 wxPyEndAllowThreads(__tstate);
6756 if (PyErr_Occurred()) SWIG_fail;
6757 }
6758 resultobj = SWIG_Py_Void();
6759 return resultobj;
6760 fail:
6761 return NULL;
6762 }
6763
6764
6765 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6766 PyObject *resultobj = 0;
6767 wxRect *arg1 = (wxRect *) 0 ;
6768 bool result;
6769 void *argp1 = 0 ;
6770 int res1 = 0 ;
6771 PyObject *swig_obj[1] ;
6772
6773 if (!args) SWIG_fail;
6774 swig_obj[0] = args;
6775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6776 if (!SWIG_IsOK(res1)) {
6777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6778 }
6779 arg1 = reinterpret_cast< wxRect * >(argp1);
6780 {
6781 PyThreadState* __tstate = wxPyBeginAllowThreads();
6782 result = (bool)((wxRect const *)arg1)->IsEmpty();
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 {
6787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6788 }
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6796 PyObject *resultobj = 0;
6797 wxRect *arg1 = (wxRect *) 0 ;
6798 wxPoint result;
6799 void *argp1 = 0 ;
6800 int res1 = 0 ;
6801 PyObject *swig_obj[1] ;
6802
6803 if (!args) SWIG_fail;
6804 swig_obj[0] = args;
6805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6806 if (!SWIG_IsOK(res1)) {
6807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6808 }
6809 arg1 = reinterpret_cast< wxRect * >(argp1);
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 result = ((wxRect const *)arg1)->GetTopLeft();
6813 wxPyEndAllowThreads(__tstate);
6814 if (PyErr_Occurred()) SWIG_fail;
6815 }
6816 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj = 0;
6825 wxRect *arg1 = (wxRect *) 0 ;
6826 wxPoint *arg2 = 0 ;
6827 void *argp1 = 0 ;
6828 int res1 = 0 ;
6829 wxPoint temp2 ;
6830 PyObject * obj0 = 0 ;
6831 PyObject * obj1 = 0 ;
6832 char * kwnames[] = {
6833 (char *) "self",(char *) "p", NULL
6834 };
6835
6836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6838 if (!SWIG_IsOK(res1)) {
6839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6840 }
6841 arg1 = reinterpret_cast< wxRect * >(argp1);
6842 {
6843 arg2 = &temp2;
6844 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6845 }
6846 {
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6849 wxPyEndAllowThreads(__tstate);
6850 if (PyErr_Occurred()) SWIG_fail;
6851 }
6852 resultobj = SWIG_Py_Void();
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6860 PyObject *resultobj = 0;
6861 wxRect *arg1 = (wxRect *) 0 ;
6862 wxPoint result;
6863 void *argp1 = 0 ;
6864 int res1 = 0 ;
6865 PyObject *swig_obj[1] ;
6866
6867 if (!args) SWIG_fail;
6868 swig_obj[0] = args;
6869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6870 if (!SWIG_IsOK(res1)) {
6871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6872 }
6873 arg1 = reinterpret_cast< wxRect * >(argp1);
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = ((wxRect const *)arg1)->GetBottomRight();
6877 wxPyEndAllowThreads(__tstate);
6878 if (PyErr_Occurred()) SWIG_fail;
6879 }
6880 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6881 return resultobj;
6882 fail:
6883 return NULL;
6884 }
6885
6886
6887 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6888 PyObject *resultobj = 0;
6889 wxRect *arg1 = (wxRect *) 0 ;
6890 wxPoint *arg2 = 0 ;
6891 void *argp1 = 0 ;
6892 int res1 = 0 ;
6893 wxPoint temp2 ;
6894 PyObject * obj0 = 0 ;
6895 PyObject * obj1 = 0 ;
6896 char * kwnames[] = {
6897 (char *) "self",(char *) "p", NULL
6898 };
6899
6900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6902 if (!SWIG_IsOK(res1)) {
6903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6904 }
6905 arg1 = reinterpret_cast< wxRect * >(argp1);
6906 {
6907 arg2 = &temp2;
6908 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6909 }
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_Py_Void();
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6924 PyObject *resultobj = 0;
6925 wxRect *arg1 = (wxRect *) 0 ;
6926 wxPoint result;
6927 void *argp1 = 0 ;
6928 int res1 = 0 ;
6929 PyObject *swig_obj[1] ;
6930
6931 if (!args) SWIG_fail;
6932 swig_obj[0] = args;
6933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6934 if (!SWIG_IsOK(res1)) {
6935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6936 }
6937 arg1 = reinterpret_cast< wxRect * >(argp1);
6938 {
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 result = ((wxRect const *)arg1)->GetTopRight();
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6945 return resultobj;
6946 fail:
6947 return NULL;
6948 }
6949
6950
6951 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6952 PyObject *resultobj = 0;
6953 wxRect *arg1 = (wxRect *) 0 ;
6954 wxPoint *arg2 = 0 ;
6955 void *argp1 = 0 ;
6956 int res1 = 0 ;
6957 wxPoint temp2 ;
6958 PyObject * obj0 = 0 ;
6959 PyObject * obj1 = 0 ;
6960 char * kwnames[] = {
6961 (char *) "self",(char *) "p", NULL
6962 };
6963
6964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6966 if (!SWIG_IsOK(res1)) {
6967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6968 }
6969 arg1 = reinterpret_cast< wxRect * >(argp1);
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 (arg1)->SetTopRight((wxPoint const &)*arg2);
6977 wxPyEndAllowThreads(__tstate);
6978 if (PyErr_Occurred()) SWIG_fail;
6979 }
6980 resultobj = SWIG_Py_Void();
6981 return resultobj;
6982 fail:
6983 return NULL;
6984 }
6985
6986
6987 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6988 PyObject *resultobj = 0;
6989 wxRect *arg1 = (wxRect *) 0 ;
6990 wxPoint result;
6991 void *argp1 = 0 ;
6992 int res1 = 0 ;
6993 PyObject *swig_obj[1] ;
6994
6995 if (!args) SWIG_fail;
6996 swig_obj[0] = args;
6997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6998 if (!SWIG_IsOK(res1)) {
6999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7000 }
7001 arg1 = reinterpret_cast< wxRect * >(argp1);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 result = ((wxRect const *)arg1)->GetBottomLeft();
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 wxPoint *arg2 = 0 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 wxPoint temp2 ;
7022 PyObject * obj0 = 0 ;
7023 PyObject * obj1 = 0 ;
7024 char * kwnames[] = {
7025 (char *) "self",(char *) "p", NULL
7026 };
7027
7028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7030 if (!SWIG_IsOK(res1)) {
7031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7032 }
7033 arg1 = reinterpret_cast< wxRect * >(argp1);
7034 {
7035 arg2 = &temp2;
7036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7037 }
7038 {
7039 PyThreadState* __tstate = wxPyBeginAllowThreads();
7040 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7041 wxPyEndAllowThreads(__tstate);
7042 if (PyErr_Occurred()) SWIG_fail;
7043 }
7044 resultobj = SWIG_Py_Void();
7045 return resultobj;
7046 fail:
7047 return NULL;
7048 }
7049
7050
7051 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7052 PyObject *resultobj = 0;
7053 wxRect *arg1 = (wxRect *) 0 ;
7054 int result;
7055 void *argp1 = 0 ;
7056 int res1 = 0 ;
7057 PyObject *swig_obj[1] ;
7058
7059 if (!args) SWIG_fail;
7060 swig_obj[0] = args;
7061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7062 if (!SWIG_IsOK(res1)) {
7063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7064 }
7065 arg1 = reinterpret_cast< wxRect * >(argp1);
7066 {
7067 PyThreadState* __tstate = wxPyBeginAllowThreads();
7068 result = (int)((wxRect const *)arg1)->GetLeft();
7069 wxPyEndAllowThreads(__tstate);
7070 if (PyErr_Occurred()) SWIG_fail;
7071 }
7072 resultobj = SWIG_From_int(static_cast< int >(result));
7073 return resultobj;
7074 fail:
7075 return NULL;
7076 }
7077
7078
7079 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7080 PyObject *resultobj = 0;
7081 wxRect *arg1 = (wxRect *) 0 ;
7082 int result;
7083 void *argp1 = 0 ;
7084 int res1 = 0 ;
7085 PyObject *swig_obj[1] ;
7086
7087 if (!args) SWIG_fail;
7088 swig_obj[0] = args;
7089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7090 if (!SWIG_IsOK(res1)) {
7091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7092 }
7093 arg1 = reinterpret_cast< wxRect * >(argp1);
7094 {
7095 PyThreadState* __tstate = wxPyBeginAllowThreads();
7096 result = (int)((wxRect const *)arg1)->GetTop();
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 resultobj = SWIG_From_int(static_cast< int >(result));
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7108 PyObject *resultobj = 0;
7109 wxRect *arg1 = (wxRect *) 0 ;
7110 int result;
7111 void *argp1 = 0 ;
7112 int res1 = 0 ;
7113 PyObject *swig_obj[1] ;
7114
7115 if (!args) SWIG_fail;
7116 swig_obj[0] = args;
7117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7118 if (!SWIG_IsOK(res1)) {
7119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7120 }
7121 arg1 = reinterpret_cast< wxRect * >(argp1);
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 result = (int)((wxRect const *)arg1)->GetBottom();
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 resultobj = SWIG_From_int(static_cast< int >(result));
7129 return resultobj;
7130 fail:
7131 return NULL;
7132 }
7133
7134
7135 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7136 PyObject *resultobj = 0;
7137 wxRect *arg1 = (wxRect *) 0 ;
7138 int result;
7139 void *argp1 = 0 ;
7140 int res1 = 0 ;
7141 PyObject *swig_obj[1] ;
7142
7143 if (!args) SWIG_fail;
7144 swig_obj[0] = args;
7145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7146 if (!SWIG_IsOK(res1)) {
7147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7148 }
7149 arg1 = reinterpret_cast< wxRect * >(argp1);
7150 {
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 result = (int)((wxRect const *)arg1)->GetRight();
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 resultobj = SWIG_From_int(static_cast< int >(result));
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj = 0;
7165 wxRect *arg1 = (wxRect *) 0 ;
7166 int arg2 ;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 int val2 ;
7170 int ecode2 = 0 ;
7171 PyObject * obj0 = 0 ;
7172 PyObject * obj1 = 0 ;
7173 char * kwnames[] = {
7174 (char *) "self",(char *) "left", NULL
7175 };
7176
7177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7179 if (!SWIG_IsOK(res1)) {
7180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7181 }
7182 arg1 = reinterpret_cast< wxRect * >(argp1);
7183 ecode2 = SWIG_AsVal_int(obj1, &val2);
7184 if (!SWIG_IsOK(ecode2)) {
7185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7186 }
7187 arg2 = static_cast< int >(val2);
7188 {
7189 PyThreadState* __tstate = wxPyBeginAllowThreads();
7190 (arg1)->SetLeft(arg2);
7191 wxPyEndAllowThreads(__tstate);
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 resultobj = SWIG_Py_Void();
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj = 0;
7203 wxRect *arg1 = (wxRect *) 0 ;
7204 int arg2 ;
7205 void *argp1 = 0 ;
7206 int res1 = 0 ;
7207 int val2 ;
7208 int ecode2 = 0 ;
7209 PyObject * obj0 = 0 ;
7210 PyObject * obj1 = 0 ;
7211 char * kwnames[] = {
7212 (char *) "self",(char *) "right", NULL
7213 };
7214
7215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7217 if (!SWIG_IsOK(res1)) {
7218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7219 }
7220 arg1 = reinterpret_cast< wxRect * >(argp1);
7221 ecode2 = SWIG_AsVal_int(obj1, &val2);
7222 if (!SWIG_IsOK(ecode2)) {
7223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7224 }
7225 arg2 = static_cast< int >(val2);
7226 {
7227 PyThreadState* __tstate = wxPyBeginAllowThreads();
7228 (arg1)->SetRight(arg2);
7229 wxPyEndAllowThreads(__tstate);
7230 if (PyErr_Occurred()) SWIG_fail;
7231 }
7232 resultobj = SWIG_Py_Void();
7233 return resultobj;
7234 fail:
7235 return NULL;
7236 }
7237
7238
7239 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7240 PyObject *resultobj = 0;
7241 wxRect *arg1 = (wxRect *) 0 ;
7242 int arg2 ;
7243 void *argp1 = 0 ;
7244 int res1 = 0 ;
7245 int val2 ;
7246 int ecode2 = 0 ;
7247 PyObject * obj0 = 0 ;
7248 PyObject * obj1 = 0 ;
7249 char * kwnames[] = {
7250 (char *) "self",(char *) "top", NULL
7251 };
7252
7253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",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_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7257 }
7258 arg1 = reinterpret_cast< wxRect * >(argp1);
7259 ecode2 = SWIG_AsVal_int(obj1, &val2);
7260 if (!SWIG_IsOK(ecode2)) {
7261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7262 }
7263 arg2 = static_cast< int >(val2);
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 (arg1)->SetTop(arg2);
7267 wxPyEndAllowThreads(__tstate);
7268 if (PyErr_Occurred()) SWIG_fail;
7269 }
7270 resultobj = SWIG_Py_Void();
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = 0;
7279 wxRect *arg1 = (wxRect *) 0 ;
7280 int arg2 ;
7281 void *argp1 = 0 ;
7282 int res1 = 0 ;
7283 int val2 ;
7284 int ecode2 = 0 ;
7285 PyObject * obj0 = 0 ;
7286 PyObject * obj1 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "bottom", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 ecode2 = SWIG_AsVal_int(obj1, &val2);
7298 if (!SWIG_IsOK(ecode2)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7300 }
7301 arg2 = static_cast< int >(val2);
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 (arg1)->SetBottom(arg2);
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 resultobj = SWIG_Py_Void();
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj = 0;
7317 wxRect *arg1 = (wxRect *) 0 ;
7318 int arg2 ;
7319 int arg3 ;
7320 wxRect *result = 0 ;
7321 void *argp1 = 0 ;
7322 int res1 = 0 ;
7323 int val2 ;
7324 int ecode2 = 0 ;
7325 int val3 ;
7326 int ecode3 = 0 ;
7327 PyObject * obj0 = 0 ;
7328 PyObject * obj1 = 0 ;
7329 PyObject * obj2 = 0 ;
7330 char * kwnames[] = {
7331 (char *) "self",(char *) "dx",(char *) "dy", NULL
7332 };
7333
7334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7336 if (!SWIG_IsOK(res1)) {
7337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7338 }
7339 arg1 = reinterpret_cast< wxRect * >(argp1);
7340 ecode2 = SWIG_AsVal_int(obj1, &val2);
7341 if (!SWIG_IsOK(ecode2)) {
7342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7343 }
7344 arg2 = static_cast< int >(val2);
7345 ecode3 = SWIG_AsVal_int(obj2, &val3);
7346 if (!SWIG_IsOK(ecode3)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7348 }
7349 arg3 = static_cast< int >(val3);
7350 {
7351 PyThreadState* __tstate = wxPyBeginAllowThreads();
7352 {
7353 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7354 result = (wxRect *) &_result_ref;
7355 }
7356 wxPyEndAllowThreads(__tstate);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj = 0;
7368 wxRect *arg1 = (wxRect *) 0 ;
7369 int arg2 ;
7370 int arg3 ;
7371 wxRect *result = 0 ;
7372 void *argp1 = 0 ;
7373 int res1 = 0 ;
7374 int val2 ;
7375 int ecode2 = 0 ;
7376 int val3 ;
7377 int ecode3 = 0 ;
7378 PyObject * obj0 = 0 ;
7379 PyObject * obj1 = 0 ;
7380 PyObject * obj2 = 0 ;
7381 char * kwnames[] = {
7382 (char *) "self",(char *) "dx",(char *) "dy", NULL
7383 };
7384
7385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7387 if (!SWIG_IsOK(res1)) {
7388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7389 }
7390 arg1 = reinterpret_cast< wxRect * >(argp1);
7391 ecode2 = SWIG_AsVal_int(obj1, &val2);
7392 if (!SWIG_IsOK(ecode2)) {
7393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7394 }
7395 arg2 = static_cast< int >(val2);
7396 ecode3 = SWIG_AsVal_int(obj2, &val3);
7397 if (!SWIG_IsOK(ecode3)) {
7398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7399 }
7400 arg3 = static_cast< int >(val3);
7401 {
7402 PyThreadState* __tstate = wxPyBeginAllowThreads();
7403 {
7404 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7405 result = (wxRect *) &_result_ref;
7406 }
7407 wxPyEndAllowThreads(__tstate);
7408 if (PyErr_Occurred()) SWIG_fail;
7409 }
7410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj = 0;
7419 wxRect *arg1 = (wxRect *) 0 ;
7420 int arg2 ;
7421 int arg3 ;
7422 void *argp1 = 0 ;
7423 int res1 = 0 ;
7424 int val2 ;
7425 int ecode2 = 0 ;
7426 int val3 ;
7427 int ecode3 = 0 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 PyObject * obj2 = 0 ;
7431 char * kwnames[] = {
7432 (char *) "self",(char *) "dx",(char *) "dy", NULL
7433 };
7434
7435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7439 }
7440 arg1 = reinterpret_cast< wxRect * >(argp1);
7441 ecode2 = SWIG_AsVal_int(obj1, &val2);
7442 if (!SWIG_IsOK(ecode2)) {
7443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7444 }
7445 arg2 = static_cast< int >(val2);
7446 ecode3 = SWIG_AsVal_int(obj2, &val3);
7447 if (!SWIG_IsOK(ecode3)) {
7448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7449 }
7450 arg3 = static_cast< int >(val3);
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 (arg1)->Offset(arg2,arg3);
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 resultobj = SWIG_Py_Void();
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj = 0;
7466 wxRect *arg1 = (wxRect *) 0 ;
7467 wxPoint *arg2 = 0 ;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 wxPoint temp2 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 char * kwnames[] = {
7474 (char *) "self",(char *) "pt", NULL
7475 };
7476
7477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7479 if (!SWIG_IsOK(res1)) {
7480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7481 }
7482 arg1 = reinterpret_cast< wxRect * >(argp1);
7483 {
7484 arg2 = &temp2;
7485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7486 }
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 (arg1)->Offset((wxPoint const &)*arg2);
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 resultobj = SWIG_Py_Void();
7494 return resultobj;
7495 fail:
7496 return NULL;
7497 }
7498
7499
7500 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7501 PyObject *resultobj = 0;
7502 wxRect *arg1 = (wxRect *) 0 ;
7503 wxRect *arg2 = 0 ;
7504 wxRect result;
7505 void *argp1 = 0 ;
7506 int res1 = 0 ;
7507 wxRect temp2 ;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "rect", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7518 }
7519 arg1 = reinterpret_cast< wxRect * >(argp1);
7520 {
7521 arg2 = &temp2;
7522 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7523 }
7524 {
7525 PyThreadState* __tstate = wxPyBeginAllowThreads();
7526 result = (arg1)->Intersect((wxRect const &)*arg2);
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj = 0;
7539 wxRect *arg1 = (wxRect *) 0 ;
7540 wxRect *arg2 = 0 ;
7541 wxRect result;
7542 void *argp1 = 0 ;
7543 int res1 = 0 ;
7544 wxRect temp2 ;
7545 PyObject * obj0 = 0 ;
7546 PyObject * obj1 = 0 ;
7547 char * kwnames[] = {
7548 (char *) "self",(char *) "rect", NULL
7549 };
7550
7551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7553 if (!SWIG_IsOK(res1)) {
7554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7555 }
7556 arg1 = reinterpret_cast< wxRect * >(argp1);
7557 {
7558 arg2 = &temp2;
7559 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7560 }
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 result = (arg1)->Union((wxRect const &)*arg2);
7564 wxPyEndAllowThreads(__tstate);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj = 0;
7576 wxRect *arg1 = (wxRect *) 0 ;
7577 wxRect *arg2 = 0 ;
7578 wxRect result;
7579 void *argp1 = 0 ;
7580 int res1 = 0 ;
7581 wxRect temp2 ;
7582 PyObject * obj0 = 0 ;
7583 PyObject * obj1 = 0 ;
7584 char * kwnames[] = {
7585 (char *) "self",(char *) "rect", NULL
7586 };
7587
7588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7592 }
7593 arg1 = reinterpret_cast< wxRect * >(argp1);
7594 {
7595 arg2 = &temp2;
7596 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7597 }
7598 {
7599 PyThreadState* __tstate = wxPyBeginAllowThreads();
7600 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7601 wxPyEndAllowThreads(__tstate);
7602 if (PyErr_Occurred()) SWIG_fail;
7603 }
7604 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7605 return resultobj;
7606 fail:
7607 return NULL;
7608 }
7609
7610
7611 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7612 PyObject *resultobj = 0;
7613 wxRect *arg1 = (wxRect *) 0 ;
7614 wxRect *arg2 = 0 ;
7615 wxRect *result = 0 ;
7616 void *argp1 = 0 ;
7617 int res1 = 0 ;
7618 wxRect temp2 ;
7619 PyObject * obj0 = 0 ;
7620 PyObject * obj1 = 0 ;
7621 char * kwnames[] = {
7622 (char *) "self",(char *) "rect", NULL
7623 };
7624
7625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7627 if (!SWIG_IsOK(res1)) {
7628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7629 }
7630 arg1 = reinterpret_cast< wxRect * >(argp1);
7631 {
7632 arg2 = &temp2;
7633 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7634 }
7635 {
7636 PyThreadState* __tstate = wxPyBeginAllowThreads();
7637 {
7638 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7639 result = (wxRect *) &_result_ref;
7640 }
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7652 PyObject *resultobj = 0;
7653 wxRect *arg1 = (wxRect *) 0 ;
7654 PyObject *arg2 = (PyObject *) 0 ;
7655 bool result;
7656 void *argp1 = 0 ;
7657 int res1 = 0 ;
7658 PyObject * obj0 = 0 ;
7659 PyObject * obj1 = 0 ;
7660 char * kwnames[] = {
7661 (char *) "self",(char *) "other", NULL
7662 };
7663
7664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7666 if (!SWIG_IsOK(res1)) {
7667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7668 }
7669 arg1 = reinterpret_cast< wxRect * >(argp1);
7670 arg2 = obj1;
7671 {
7672 result = (bool)wxRect___eq__(arg1,arg2);
7673 if (PyErr_Occurred()) SWIG_fail;
7674 }
7675 {
7676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7677 }
7678 return resultobj;
7679 fail:
7680 return NULL;
7681 }
7682
7683
7684 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7685 PyObject *resultobj = 0;
7686 wxRect *arg1 = (wxRect *) 0 ;
7687 PyObject *arg2 = (PyObject *) 0 ;
7688 bool result;
7689 void *argp1 = 0 ;
7690 int res1 = 0 ;
7691 PyObject * obj0 = 0 ;
7692 PyObject * obj1 = 0 ;
7693 char * kwnames[] = {
7694 (char *) "self",(char *) "other", NULL
7695 };
7696
7697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7699 if (!SWIG_IsOK(res1)) {
7700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7701 }
7702 arg1 = reinterpret_cast< wxRect * >(argp1);
7703 arg2 = obj1;
7704 {
7705 result = (bool)wxRect___ne__(arg1,arg2);
7706 if (PyErr_Occurred()) SWIG_fail;
7707 }
7708 {
7709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7710 }
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj = 0;
7719 wxRect *arg1 = (wxRect *) 0 ;
7720 int arg2 ;
7721 int arg3 ;
7722 bool result;
7723 void *argp1 = 0 ;
7724 int res1 = 0 ;
7725 int val2 ;
7726 int ecode2 = 0 ;
7727 int val3 ;
7728 int ecode3 = 0 ;
7729 PyObject * obj0 = 0 ;
7730 PyObject * obj1 = 0 ;
7731 PyObject * obj2 = 0 ;
7732 char * kwnames[] = {
7733 (char *) "self",(char *) "x",(char *) "y", NULL
7734 };
7735
7736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7738 if (!SWIG_IsOK(res1)) {
7739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7740 }
7741 arg1 = reinterpret_cast< wxRect * >(argp1);
7742 ecode2 = SWIG_AsVal_int(obj1, &val2);
7743 if (!SWIG_IsOK(ecode2)) {
7744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7745 }
7746 arg2 = static_cast< int >(val2);
7747 ecode3 = SWIG_AsVal_int(obj2, &val3);
7748 if (!SWIG_IsOK(ecode3)) {
7749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7750 }
7751 arg3 = static_cast< int >(val3);
7752 {
7753 PyThreadState* __tstate = wxPyBeginAllowThreads();
7754 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7755 wxPyEndAllowThreads(__tstate);
7756 if (PyErr_Occurred()) SWIG_fail;
7757 }
7758 {
7759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7760 }
7761 return resultobj;
7762 fail:
7763 return NULL;
7764 }
7765
7766
7767 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7768 PyObject *resultobj = 0;
7769 wxRect *arg1 = (wxRect *) 0 ;
7770 wxPoint *arg2 = 0 ;
7771 bool result;
7772 void *argp1 = 0 ;
7773 int res1 = 0 ;
7774 wxPoint temp2 ;
7775 PyObject * obj0 = 0 ;
7776 PyObject * obj1 = 0 ;
7777 char * kwnames[] = {
7778 (char *) "self",(char *) "pt", NULL
7779 };
7780
7781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7783 if (!SWIG_IsOK(res1)) {
7784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7785 }
7786 arg1 = reinterpret_cast< wxRect * >(argp1);
7787 {
7788 arg2 = &temp2;
7789 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7790 }
7791 {
7792 PyThreadState* __tstate = wxPyBeginAllowThreads();
7793 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7799 }
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj = 0;
7808 wxRect *arg1 = (wxRect *) 0 ;
7809 wxRect *arg2 = 0 ;
7810 bool result;
7811 void *argp1 = 0 ;
7812 int res1 = 0 ;
7813 wxRect temp2 ;
7814 PyObject * obj0 = 0 ;
7815 PyObject * obj1 = 0 ;
7816 char * kwnames[] = {
7817 (char *) "self",(char *) "rect", NULL
7818 };
7819
7820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7822 if (!SWIG_IsOK(res1)) {
7823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7824 }
7825 arg1 = reinterpret_cast< wxRect * >(argp1);
7826 {
7827 arg2 = &temp2;
7828 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7829 }
7830 {
7831 PyThreadState* __tstate = wxPyBeginAllowThreads();
7832 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7833 wxPyEndAllowThreads(__tstate);
7834 if (PyErr_Occurred()) SWIG_fail;
7835 }
7836 {
7837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7838 }
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 wxRect *arg2 = 0 ;
7849 bool result;
7850 void *argp1 = 0 ;
7851 int res1 = 0 ;
7852 wxRect temp2 ;
7853 PyObject * obj0 = 0 ;
7854 PyObject * obj1 = 0 ;
7855 char * kwnames[] = {
7856 (char *) "self",(char *) "rect", NULL
7857 };
7858
7859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7861 if (!SWIG_IsOK(res1)) {
7862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7863 }
7864 arg1 = reinterpret_cast< wxRect * >(argp1);
7865 {
7866 arg2 = &temp2;
7867 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7868 }
7869 {
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 {
7876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7877 }
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7885 PyObject *resultobj = 0;
7886 wxRect *arg1 = (wxRect *) 0 ;
7887 wxRect *arg2 = 0 ;
7888 int arg3 = (int) wxBOTH ;
7889 wxRect result;
7890 void *argp1 = 0 ;
7891 int res1 = 0 ;
7892 wxRect temp2 ;
7893 int val3 ;
7894 int ecode3 = 0 ;
7895 PyObject * obj0 = 0 ;
7896 PyObject * obj1 = 0 ;
7897 PyObject * obj2 = 0 ;
7898 char * kwnames[] = {
7899 (char *) "self",(char *) "r",(char *) "dir", NULL
7900 };
7901
7902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7904 if (!SWIG_IsOK(res1)) {
7905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7906 }
7907 arg1 = reinterpret_cast< wxRect * >(argp1);
7908 {
7909 arg2 = &temp2;
7910 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7911 }
7912 if (obj2) {
7913 ecode3 = SWIG_AsVal_int(obj2, &val3);
7914 if (!SWIG_IsOK(ecode3)) {
7915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7916 }
7917 arg3 = static_cast< int >(val3);
7918 }
7919 {
7920 PyThreadState* __tstate = wxPyBeginAllowThreads();
7921 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7933 PyObject *resultobj = 0;
7934 wxRect *arg1 = (wxRect *) 0 ;
7935 int arg2 ;
7936 void *argp1 = 0 ;
7937 int res1 = 0 ;
7938 int val2 ;
7939 int ecode2 = 0 ;
7940 PyObject *swig_obj[2] ;
7941
7942 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7944 if (!SWIG_IsOK(res1)) {
7945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7946 }
7947 arg1 = reinterpret_cast< wxRect * >(argp1);
7948 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7949 if (!SWIG_IsOK(ecode2)) {
7950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7951 }
7952 arg2 = static_cast< int >(val2);
7953 if (arg1) (arg1)->x = arg2;
7954
7955 resultobj = SWIG_Py_Void();
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7963 PyObject *resultobj = 0;
7964 wxRect *arg1 = (wxRect *) 0 ;
7965 int result;
7966 void *argp1 = 0 ;
7967 int res1 = 0 ;
7968 PyObject *swig_obj[1] ;
7969
7970 if (!args) SWIG_fail;
7971 swig_obj[0] = args;
7972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7973 if (!SWIG_IsOK(res1)) {
7974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7975 }
7976 arg1 = reinterpret_cast< wxRect * >(argp1);
7977 result = (int) ((arg1)->x);
7978 resultobj = SWIG_From_int(static_cast< int >(result));
7979 return resultobj;
7980 fail:
7981 return NULL;
7982 }
7983
7984
7985 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7986 PyObject *resultobj = 0;
7987 wxRect *arg1 = (wxRect *) 0 ;
7988 int arg2 ;
7989 void *argp1 = 0 ;
7990 int res1 = 0 ;
7991 int val2 ;
7992 int ecode2 = 0 ;
7993 PyObject *swig_obj[2] ;
7994
7995 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7997 if (!SWIG_IsOK(res1)) {
7998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7999 }
8000 arg1 = reinterpret_cast< wxRect * >(argp1);
8001 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8002 if (!SWIG_IsOK(ecode2)) {
8003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8004 }
8005 arg2 = static_cast< int >(val2);
8006 if (arg1) (arg1)->y = arg2;
8007
8008 resultobj = SWIG_Py_Void();
8009 return resultobj;
8010 fail:
8011 return NULL;
8012 }
8013
8014
8015 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8016 PyObject *resultobj = 0;
8017 wxRect *arg1 = (wxRect *) 0 ;
8018 int result;
8019 void *argp1 = 0 ;
8020 int res1 = 0 ;
8021 PyObject *swig_obj[1] ;
8022
8023 if (!args) SWIG_fail;
8024 swig_obj[0] = args;
8025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8026 if (!SWIG_IsOK(res1)) {
8027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8028 }
8029 arg1 = reinterpret_cast< wxRect * >(argp1);
8030 result = (int) ((arg1)->y);
8031 resultobj = SWIG_From_int(static_cast< int >(result));
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8039 PyObject *resultobj = 0;
8040 wxRect *arg1 = (wxRect *) 0 ;
8041 int arg2 ;
8042 void *argp1 = 0 ;
8043 int res1 = 0 ;
8044 int val2 ;
8045 int ecode2 = 0 ;
8046 PyObject *swig_obj[2] ;
8047
8048 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8055 if (!SWIG_IsOK(ecode2)) {
8056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8057 }
8058 arg2 = static_cast< int >(val2);
8059 if (arg1) (arg1)->width = arg2;
8060
8061 resultobj = SWIG_Py_Void();
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069 PyObject *resultobj = 0;
8070 wxRect *arg1 = (wxRect *) 0 ;
8071 int result;
8072 void *argp1 = 0 ;
8073 int res1 = 0 ;
8074 PyObject *swig_obj[1] ;
8075
8076 if (!args) SWIG_fail;
8077 swig_obj[0] = args;
8078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8079 if (!SWIG_IsOK(res1)) {
8080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8081 }
8082 arg1 = reinterpret_cast< wxRect * >(argp1);
8083 result = (int) ((arg1)->width);
8084 resultobj = SWIG_From_int(static_cast< int >(result));
8085 return resultobj;
8086 fail:
8087 return NULL;
8088 }
8089
8090
8091 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8092 PyObject *resultobj = 0;
8093 wxRect *arg1 = (wxRect *) 0 ;
8094 int arg2 ;
8095 void *argp1 = 0 ;
8096 int res1 = 0 ;
8097 int val2 ;
8098 int ecode2 = 0 ;
8099 PyObject *swig_obj[2] ;
8100
8101 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8103 if (!SWIG_IsOK(res1)) {
8104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8105 }
8106 arg1 = reinterpret_cast< wxRect * >(argp1);
8107 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8108 if (!SWIG_IsOK(ecode2)) {
8109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8110 }
8111 arg2 = static_cast< int >(val2);
8112 if (arg1) (arg1)->height = arg2;
8113
8114 resultobj = SWIG_Py_Void();
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8122 PyObject *resultobj = 0;
8123 wxRect *arg1 = (wxRect *) 0 ;
8124 int result;
8125 void *argp1 = 0 ;
8126 int res1 = 0 ;
8127 PyObject *swig_obj[1] ;
8128
8129 if (!args) SWIG_fail;
8130 swig_obj[0] = args;
8131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8132 if (!SWIG_IsOK(res1)) {
8133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8134 }
8135 arg1 = reinterpret_cast< wxRect * >(argp1);
8136 result = (int) ((arg1)->height);
8137 resultobj = SWIG_From_int(static_cast< int >(result));
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj = 0;
8146 wxRect *arg1 = (wxRect *) 0 ;
8147 int arg2 = (int) 0 ;
8148 int arg3 = (int) 0 ;
8149 int arg4 = (int) 0 ;
8150 int arg5 = (int) 0 ;
8151 void *argp1 = 0 ;
8152 int res1 = 0 ;
8153 int val2 ;
8154 int ecode2 = 0 ;
8155 int val3 ;
8156 int ecode3 = 0 ;
8157 int val4 ;
8158 int ecode4 = 0 ;
8159 int val5 ;
8160 int ecode5 = 0 ;
8161 PyObject * obj0 = 0 ;
8162 PyObject * obj1 = 0 ;
8163 PyObject * obj2 = 0 ;
8164 PyObject * obj3 = 0 ;
8165 PyObject * obj4 = 0 ;
8166 char * kwnames[] = {
8167 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8168 };
8169
8170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8172 if (!SWIG_IsOK(res1)) {
8173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8174 }
8175 arg1 = reinterpret_cast< wxRect * >(argp1);
8176 if (obj1) {
8177 ecode2 = SWIG_AsVal_int(obj1, &val2);
8178 if (!SWIG_IsOK(ecode2)) {
8179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8180 }
8181 arg2 = static_cast< int >(val2);
8182 }
8183 if (obj2) {
8184 ecode3 = SWIG_AsVal_int(obj2, &val3);
8185 if (!SWIG_IsOK(ecode3)) {
8186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8187 }
8188 arg3 = static_cast< int >(val3);
8189 }
8190 if (obj3) {
8191 ecode4 = SWIG_AsVal_int(obj3, &val4);
8192 if (!SWIG_IsOK(ecode4)) {
8193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8194 }
8195 arg4 = static_cast< int >(val4);
8196 }
8197 if (obj4) {
8198 ecode5 = SWIG_AsVal_int(obj4, &val5);
8199 if (!SWIG_IsOK(ecode5)) {
8200 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8201 }
8202 arg5 = static_cast< int >(val5);
8203 }
8204 {
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8207 wxPyEndAllowThreads(__tstate);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_Py_Void();
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8218 PyObject *resultobj = 0;
8219 wxRect *arg1 = (wxRect *) 0 ;
8220 PyObject *result = 0 ;
8221 void *argp1 = 0 ;
8222 int res1 = 0 ;
8223 PyObject *swig_obj[1] ;
8224
8225 if (!args) SWIG_fail;
8226 swig_obj[0] = args;
8227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8228 if (!SWIG_IsOK(res1)) {
8229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8230 }
8231 arg1 = reinterpret_cast< wxRect * >(argp1);
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 result = (PyObject *)wxRect_Get(arg1);
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 resultobj = result;
8239 return resultobj;
8240 fail:
8241 return NULL;
8242 }
8243
8244
8245 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8246 PyObject *obj;
8247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8248 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8249 return SWIG_Py_Void();
8250 }
8251
8252 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8253 return SWIG_Python_InitShadowInstance(args);
8254 }
8255
8256 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8257 PyObject *resultobj = 0;
8258 wxRect *arg1 = (wxRect *) 0 ;
8259 wxRect *arg2 = (wxRect *) 0 ;
8260 PyObject *result = 0 ;
8261 void *argp1 = 0 ;
8262 int res1 = 0 ;
8263 void *argp2 = 0 ;
8264 int res2 = 0 ;
8265 PyObject * obj0 = 0 ;
8266 PyObject * obj1 = 0 ;
8267 char * kwnames[] = {
8268 (char *) "r1",(char *) "r2", NULL
8269 };
8270
8271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8273 if (!SWIG_IsOK(res1)) {
8274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8275 }
8276 arg1 = reinterpret_cast< wxRect * >(argp1);
8277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8278 if (!SWIG_IsOK(res2)) {
8279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8280 }
8281 arg2 = reinterpret_cast< wxRect * >(argp2);
8282 {
8283 if (!wxPyCheckForApp()) SWIG_fail;
8284 PyThreadState* __tstate = wxPyBeginAllowThreads();
8285 result = (PyObject *)wxIntersectRect(arg1,arg2);
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 resultobj = result;
8290 return resultobj;
8291 fail:
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj = 0;
8298 double arg1 = (double) 0.0 ;
8299 double arg2 = (double) 0.0 ;
8300 wxPoint2D *result = 0 ;
8301 double val1 ;
8302 int ecode1 = 0 ;
8303 double val2 ;
8304 int ecode2 = 0 ;
8305 PyObject * obj0 = 0 ;
8306 PyObject * obj1 = 0 ;
8307 char * kwnames[] = {
8308 (char *) "x",(char *) "y", NULL
8309 };
8310
8311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8312 if (obj0) {
8313 ecode1 = SWIG_AsVal_double(obj0, &val1);
8314 if (!SWIG_IsOK(ecode1)) {
8315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8316 }
8317 arg1 = static_cast< double >(val1);
8318 }
8319 if (obj1) {
8320 ecode2 = SWIG_AsVal_double(obj1, &val2);
8321 if (!SWIG_IsOK(ecode2)) {
8322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8323 }
8324 arg2 = static_cast< double >(val2);
8325 }
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = 0 ;
8342 wxPoint2D *result = 0 ;
8343 wxPoint2D temp1 ;
8344 PyObject * obj0 = 0 ;
8345 char * kwnames[] = {
8346 (char *) "pt", NULL
8347 };
8348
8349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8350 {
8351 arg1 = &temp1;
8352 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8353 }
8354 {
8355 PyThreadState* __tstate = wxPyBeginAllowThreads();
8356 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8357 wxPyEndAllowThreads(__tstate);
8358 if (PyErr_Occurred()) SWIG_fail;
8359 }
8360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8361 return resultobj;
8362 fail:
8363 return NULL;
8364 }
8365
8366
8367 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8368 PyObject *resultobj = 0;
8369 wxPoint *arg1 = 0 ;
8370 wxPoint2D *result = 0 ;
8371 wxPoint temp1 ;
8372 PyObject * obj0 = 0 ;
8373 char * kwnames[] = {
8374 (char *) "pt", NULL
8375 };
8376
8377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8378 {
8379 arg1 = &temp1;
8380 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8381 }
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8385 wxPyEndAllowThreads(__tstate);
8386 if (PyErr_Occurred()) SWIG_fail;
8387 }
8388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8389 return resultobj;
8390 fail:
8391 return NULL;
8392 }
8393
8394
8395 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8396 PyObject *resultobj = 0;
8397 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 PyObject *swig_obj[1] ;
8401
8402 if (!args) SWIG_fail;
8403 swig_obj[0] = args;
8404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 PyThreadState* __tstate = wxPyBeginAllowThreads();
8411 delete arg1;
8412
8413 wxPyEndAllowThreads(__tstate);
8414 if (PyErr_Occurred()) SWIG_fail;
8415 }
8416 resultobj = SWIG_Py_Void();
8417 return resultobj;
8418 fail:
8419 return NULL;
8420 }
8421
8422
8423 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8424 PyObject *resultobj = 0;
8425 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8426 int *arg2 = (int *) 0 ;
8427 int *arg3 = (int *) 0 ;
8428 void *argp1 = 0 ;
8429 int res1 = 0 ;
8430 int temp2 ;
8431 int res2 = SWIG_TMPOBJ ;
8432 int temp3 ;
8433 int res3 = SWIG_TMPOBJ ;
8434 PyObject *swig_obj[1] ;
8435
8436 arg2 = &temp2;
8437 arg3 = &temp3;
8438 if (!args) SWIG_fail;
8439 swig_obj[0] = args;
8440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8441 if (!SWIG_IsOK(res1)) {
8442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8443 }
8444 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8445 {
8446 PyThreadState* __tstate = wxPyBeginAllowThreads();
8447 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8448 wxPyEndAllowThreads(__tstate);
8449 if (PyErr_Occurred()) SWIG_fail;
8450 }
8451 resultobj = SWIG_Py_Void();
8452 if (SWIG_IsTmpObj(res2)) {
8453 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8454 } else {
8455 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8456 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8457 }
8458 if (SWIG_IsTmpObj(res3)) {
8459 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8460 } else {
8461 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8463 }
8464 return resultobj;
8465 fail:
8466 return NULL;
8467 }
8468
8469
8470 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8471 PyObject *resultobj = 0;
8472 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8473 int *arg2 = (int *) 0 ;
8474 int *arg3 = (int *) 0 ;
8475 void *argp1 = 0 ;
8476 int res1 = 0 ;
8477 int temp2 ;
8478 int res2 = SWIG_TMPOBJ ;
8479 int temp3 ;
8480 int res3 = SWIG_TMPOBJ ;
8481 PyObject *swig_obj[1] ;
8482
8483 arg2 = &temp2;
8484 arg3 = &temp3;
8485 if (!args) SWIG_fail;
8486 swig_obj[0] = args;
8487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8488 if (!SWIG_IsOK(res1)) {
8489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8490 }
8491 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8492 {
8493 PyThreadState* __tstate = wxPyBeginAllowThreads();
8494 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8495 wxPyEndAllowThreads(__tstate);
8496 if (PyErr_Occurred()) SWIG_fail;
8497 }
8498 resultobj = SWIG_Py_Void();
8499 if (SWIG_IsTmpObj(res2)) {
8500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8501 } else {
8502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8504 }
8505 if (SWIG_IsTmpObj(res3)) {
8506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8507 } else {
8508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8510 }
8511 return resultobj;
8512 fail:
8513 return NULL;
8514 }
8515
8516
8517 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8518 PyObject *resultobj = 0;
8519 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8520 double result;
8521 void *argp1 = 0 ;
8522 int res1 = 0 ;
8523 PyObject *swig_obj[1] ;
8524
8525 if (!args) SWIG_fail;
8526 swig_obj[0] = args;
8527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8528 if (!SWIG_IsOK(res1)) {
8529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8530 }
8531 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
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_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8548 double 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_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_From_double(static_cast< double >(result));
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8576 double arg2 ;
8577 void *argp1 = 0 ;
8578 int res1 = 0 ;
8579 double val2 ;
8580 int ecode2 = 0 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "length", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8591 }
8592 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8593 ecode2 = SWIG_AsVal_double(obj1, &val2);
8594 if (!SWIG_IsOK(ecode2)) {
8595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8596 }
8597 arg2 = static_cast< double >(val2);
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 (arg1)->SetVectorLength(arg2);
8601 wxPyEndAllowThreads(__tstate);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 resultobj = SWIG_Py_Void();
8605 return resultobj;
8606 fail:
8607 return NULL;
8608 }
8609
8610
8611 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8612 PyObject *resultobj = 0;
8613 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8614 double arg2 ;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 double val2 ;
8618 int ecode2 = 0 ;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 char * kwnames[] = {
8622 (char *) "self",(char *) "degrees", NULL
8623 };
8624
8625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8627 if (!SWIG_IsOK(res1)) {
8628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8629 }
8630 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8631 ecode2 = SWIG_AsVal_double(obj1, &val2);
8632 if (!SWIG_IsOK(ecode2)) {
8633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8634 }
8635 arg2 = static_cast< double >(val2);
8636 {
8637 PyThreadState* __tstate = wxPyBeginAllowThreads();
8638 (arg1)->SetVectorAngle(arg2);
8639 wxPyEndAllowThreads(__tstate);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 resultobj = SWIG_Py_Void();
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8650 PyObject *resultobj = 0;
8651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8652 wxPoint2D *arg2 = 0 ;
8653 double result;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 wxPoint2D temp2 ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char * kwnames[] = {
8660 (char *) "self",(char *) "pt", NULL
8661 };
8662
8663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8665 if (!SWIG_IsOK(res1)) {
8666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8667 }
8668 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8669 {
8670 arg2 = &temp2;
8671 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8672 }
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8676 wxPyEndAllowThreads(__tstate);
8677 if (PyErr_Occurred()) SWIG_fail;
8678 }
8679 resultobj = SWIG_From_double(static_cast< double >(result));
8680 return resultobj;
8681 fail:
8682 return NULL;
8683 }
8684
8685
8686 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8687 PyObject *resultobj = 0;
8688 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8689 wxPoint2D *arg2 = 0 ;
8690 double result;
8691 void *argp1 = 0 ;
8692 int res1 = 0 ;
8693 wxPoint2D temp2 ;
8694 PyObject * obj0 = 0 ;
8695 PyObject * obj1 = 0 ;
8696 char * kwnames[] = {
8697 (char *) "self",(char *) "pt", NULL
8698 };
8699
8700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8702 if (!SWIG_IsOK(res1)) {
8703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8704 }
8705 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8706 {
8707 arg2 = &temp2;
8708 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8709 }
8710 {
8711 PyThreadState* __tstate = wxPyBeginAllowThreads();
8712 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8713 wxPyEndAllowThreads(__tstate);
8714 if (PyErr_Occurred()) SWIG_fail;
8715 }
8716 resultobj = SWIG_From_double(static_cast< double >(result));
8717 return resultobj;
8718 fail:
8719 return NULL;
8720 }
8721
8722
8723 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8724 PyObject *resultobj = 0;
8725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8726 wxPoint2D *arg2 = 0 ;
8727 double result;
8728 void *argp1 = 0 ;
8729 int res1 = 0 ;
8730 wxPoint2D temp2 ;
8731 PyObject * obj0 = 0 ;
8732 PyObject * obj1 = 0 ;
8733 char * kwnames[] = {
8734 (char *) "self",(char *) "vec", NULL
8735 };
8736
8737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8739 if (!SWIG_IsOK(res1)) {
8740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8741 }
8742 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8743 {
8744 arg2 = &temp2;
8745 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8746 }
8747 {
8748 PyThreadState* __tstate = wxPyBeginAllowThreads();
8749 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8750 wxPyEndAllowThreads(__tstate);
8751 if (PyErr_Occurred()) SWIG_fail;
8752 }
8753 resultobj = SWIG_From_double(static_cast< double >(result));
8754 return resultobj;
8755 fail:
8756 return NULL;
8757 }
8758
8759
8760 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8761 PyObject *resultobj = 0;
8762 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8763 wxPoint2D *arg2 = 0 ;
8764 double result;
8765 void *argp1 = 0 ;
8766 int res1 = 0 ;
8767 wxPoint2D temp2 ;
8768 PyObject * obj0 = 0 ;
8769 PyObject * obj1 = 0 ;
8770 char * kwnames[] = {
8771 (char *) "self",(char *) "vec", NULL
8772 };
8773
8774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8776 if (!SWIG_IsOK(res1)) {
8777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8778 }
8779 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8780 {
8781 arg2 = &temp2;
8782 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8783 }
8784 {
8785 PyThreadState* __tstate = wxPyBeginAllowThreads();
8786 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8787 wxPyEndAllowThreads(__tstate);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 resultobj = SWIG_From_double(static_cast< double >(result));
8791 return resultobj;
8792 fail:
8793 return NULL;
8794 }
8795
8796
8797 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8798 PyObject *resultobj = 0;
8799 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8800 wxPoint2D result;
8801 void *argp1 = 0 ;
8802 int res1 = 0 ;
8803 PyObject *swig_obj[1] ;
8804
8805 if (!args) SWIG_fail;
8806 swig_obj[0] = args;
8807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8810 }
8811 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 result = (arg1)->operator -();
8815 wxPyEndAllowThreads(__tstate);
8816 if (PyErr_Occurred()) SWIG_fail;
8817 }
8818 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8826 PyObject *resultobj = 0;
8827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8828 wxPoint2D *arg2 = 0 ;
8829 wxPoint2D *result = 0 ;
8830 void *argp1 = 0 ;
8831 int res1 = 0 ;
8832 wxPoint2D temp2 ;
8833 PyObject * obj0 = 0 ;
8834 PyObject * obj1 = 0 ;
8835 char * kwnames[] = {
8836 (char *) "self",(char *) "pt", NULL
8837 };
8838
8839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8841 if (!SWIG_IsOK(res1)) {
8842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8843 }
8844 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8845 {
8846 arg2 = &temp2;
8847 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8848 }
8849 {
8850 PyThreadState* __tstate = wxPyBeginAllowThreads();
8851 {
8852 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8853 result = (wxPoint2D *) &_result_ref;
8854 }
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8866 PyObject *resultobj = 0;
8867 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8868 wxPoint2D *arg2 = 0 ;
8869 wxPoint2D *result = 0 ;
8870 void *argp1 = 0 ;
8871 int res1 = 0 ;
8872 wxPoint2D temp2 ;
8873 PyObject * obj0 = 0 ;
8874 PyObject * obj1 = 0 ;
8875 char * kwnames[] = {
8876 (char *) "self",(char *) "pt", NULL
8877 };
8878
8879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8881 if (!SWIG_IsOK(res1)) {
8882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8883 }
8884 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8885 {
8886 arg2 = &temp2;
8887 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8888 }
8889 {
8890 PyThreadState* __tstate = wxPyBeginAllowThreads();
8891 {
8892 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8893 result = (wxPoint2D *) &_result_ref;
8894 }
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8908 wxPoint2D *arg2 = 0 ;
8909 wxPoint2D *result = 0 ;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 wxPoint2D temp2 ;
8913 PyObject * obj0 = 0 ;
8914 PyObject * obj1 = 0 ;
8915 char * kwnames[] = {
8916 (char *) "self",(char *) "pt", NULL
8917 };
8918
8919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8921 if (!SWIG_IsOK(res1)) {
8922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8923 }
8924 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8925 {
8926 arg2 = &temp2;
8927 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8928 }
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 {
8932 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8933 result = (wxPoint2D *) &_result_ref;
8934 }
8935 wxPyEndAllowThreads(__tstate);
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj = 0;
8947 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8948 wxPoint2D *arg2 = 0 ;
8949 wxPoint2D *result = 0 ;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 wxPoint2D temp2 ;
8953 PyObject * obj0 = 0 ;
8954 PyObject * obj1 = 0 ;
8955 char * kwnames[] = {
8956 (char *) "self",(char *) "pt", NULL
8957 };
8958
8959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8961 if (!SWIG_IsOK(res1)) {
8962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8963 }
8964 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8965 {
8966 arg2 = &temp2;
8967 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8968 }
8969 {
8970 PyThreadState* __tstate = wxPyBeginAllowThreads();
8971 {
8972 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8973 result = (wxPoint2D *) &_result_ref;
8974 }
8975 wxPyEndAllowThreads(__tstate);
8976 if (PyErr_Occurred()) SWIG_fail;
8977 }
8978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8979 return resultobj;
8980 fail:
8981 return NULL;
8982 }
8983
8984
8985 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = 0;
8987 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8988 PyObject *arg2 = (PyObject *) 0 ;
8989 bool result;
8990 void *argp1 = 0 ;
8991 int res1 = 0 ;
8992 PyObject * obj0 = 0 ;
8993 PyObject * obj1 = 0 ;
8994 char * kwnames[] = {
8995 (char *) "self",(char *) "other", NULL
8996 };
8997
8998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9000 if (!SWIG_IsOK(res1)) {
9001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9002 }
9003 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9004 arg2 = obj1;
9005 {
9006 result = (bool)wxPoint2D___eq__(arg1,arg2);
9007 if (PyErr_Occurred()) SWIG_fail;
9008 }
9009 {
9010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9011 }
9012 return resultobj;
9013 fail:
9014 return NULL;
9015 }
9016
9017
9018 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9019 PyObject *resultobj = 0;
9020 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9021 PyObject *arg2 = (PyObject *) 0 ;
9022 bool result;
9023 void *argp1 = 0 ;
9024 int res1 = 0 ;
9025 PyObject * obj0 = 0 ;
9026 PyObject * obj1 = 0 ;
9027 char * kwnames[] = {
9028 (char *) "self",(char *) "other", NULL
9029 };
9030
9031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9033 if (!SWIG_IsOK(res1)) {
9034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9035 }
9036 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9037 arg2 = obj1;
9038 {
9039 result = (bool)wxPoint2D___ne__(arg1,arg2);
9040 if (PyErr_Occurred()) SWIG_fail;
9041 }
9042 {
9043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9044 }
9045 return resultobj;
9046 fail:
9047 return NULL;
9048 }
9049
9050
9051 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9052 PyObject *resultobj = 0;
9053 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9054 double arg2 ;
9055 void *argp1 = 0 ;
9056 int res1 = 0 ;
9057 double val2 ;
9058 int ecode2 = 0 ;
9059 PyObject *swig_obj[2] ;
9060
9061 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9063 if (!SWIG_IsOK(res1)) {
9064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9065 }
9066 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9067 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9068 if (!SWIG_IsOK(ecode2)) {
9069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9070 }
9071 arg2 = static_cast< double >(val2);
9072 if (arg1) (arg1)->m_x = arg2;
9073
9074 resultobj = SWIG_Py_Void();
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9082 PyObject *resultobj = 0;
9083 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9084 double result;
9085 void *argp1 = 0 ;
9086 int res1 = 0 ;
9087 PyObject *swig_obj[1] ;
9088
9089 if (!args) SWIG_fail;
9090 swig_obj[0] = args;
9091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9092 if (!SWIG_IsOK(res1)) {
9093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9094 }
9095 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9096 result = (double) ((arg1)->m_x);
9097 resultobj = SWIG_From_double(static_cast< double >(result));
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105 PyObject *resultobj = 0;
9106 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9107 double arg2 ;
9108 void *argp1 = 0 ;
9109 int res1 = 0 ;
9110 double val2 ;
9111 int ecode2 = 0 ;
9112 PyObject *swig_obj[2] ;
9113
9114 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9116 if (!SWIG_IsOK(res1)) {
9117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9118 }
9119 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9120 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9121 if (!SWIG_IsOK(ecode2)) {
9122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9123 }
9124 arg2 = static_cast< double >(val2);
9125 if (arg1) (arg1)->m_y = arg2;
9126
9127 resultobj = SWIG_Py_Void();
9128 return resultobj;
9129 fail:
9130 return NULL;
9131 }
9132
9133
9134 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9135 PyObject *resultobj = 0;
9136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9137 double result;
9138 void *argp1 = 0 ;
9139 int res1 = 0 ;
9140 PyObject *swig_obj[1] ;
9141
9142 if (!args) SWIG_fail;
9143 swig_obj[0] = args;
9144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9145 if (!SWIG_IsOK(res1)) {
9146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9147 }
9148 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9149 result = (double) ((arg1)->m_y);
9150 resultobj = SWIG_From_double(static_cast< double >(result));
9151 return resultobj;
9152 fail:
9153 return NULL;
9154 }
9155
9156
9157 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9158 PyObject *resultobj = 0;
9159 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9160 double arg2 = (double) 0 ;
9161 double arg3 = (double) 0 ;
9162 void *argp1 = 0 ;
9163 int res1 = 0 ;
9164 double val2 ;
9165 int ecode2 = 0 ;
9166 double val3 ;
9167 int ecode3 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 PyObject * obj2 = 0 ;
9171 char * kwnames[] = {
9172 (char *) "self",(char *) "x",(char *) "y", NULL
9173 };
9174
9175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9181 if (obj1) {
9182 ecode2 = SWIG_AsVal_double(obj1, &val2);
9183 if (!SWIG_IsOK(ecode2)) {
9184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9185 }
9186 arg2 = static_cast< double >(val2);
9187 }
9188 if (obj2) {
9189 ecode3 = SWIG_AsVal_double(obj2, &val3);
9190 if (!SWIG_IsOK(ecode3)) {
9191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9192 }
9193 arg3 = static_cast< double >(val3);
9194 }
9195 {
9196 PyThreadState* __tstate = wxPyBeginAllowThreads();
9197 wxPoint2D_Set(arg1,arg2,arg3);
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 resultobj = SWIG_Py_Void();
9202 return resultobj;
9203 fail:
9204 return NULL;
9205 }
9206
9207
9208 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9209 PyObject *resultobj = 0;
9210 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9211 PyObject *result = 0 ;
9212 void *argp1 = 0 ;
9213 int res1 = 0 ;
9214 PyObject *swig_obj[1] ;
9215
9216 if (!args) SWIG_fail;
9217 swig_obj[0] = args;
9218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9219 if (!SWIG_IsOK(res1)) {
9220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9221 }
9222 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9223 {
9224 PyThreadState* __tstate = wxPyBeginAllowThreads();
9225 result = (PyObject *)wxPoint2D_Get(arg1);
9226 wxPyEndAllowThreads(__tstate);
9227 if (PyErr_Occurred()) SWIG_fail;
9228 }
9229 resultobj = result;
9230 return resultobj;
9231 fail:
9232 return NULL;
9233 }
9234
9235
9236 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9237 PyObject *obj;
9238 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9239 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9240 return SWIG_Py_Void();
9241 }
9242
9243 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 return SWIG_Python_InitShadowInstance(args);
9245 }
9246
9247 SWIGINTERN int DefaultPosition_set(PyObject *) {
9248 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9249 return 1;
9250 }
9251
9252
9253 SWIGINTERN PyObject *DefaultPosition_get(void) {
9254 PyObject *pyobj = 0;
9255
9256 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9257 return pyobj;
9258 }
9259
9260
9261 SWIGINTERN int DefaultSize_set(PyObject *) {
9262 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9263 return 1;
9264 }
9265
9266
9267 SWIGINTERN PyObject *DefaultSize_get(void) {
9268 PyObject *pyobj = 0;
9269
9270 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9271 return pyobj;
9272 }
9273
9274
9275 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9276 PyObject *resultobj = 0;
9277 PyObject *arg1 = (PyObject *) 0 ;
9278 wxPyInputStream *result = 0 ;
9279 PyObject * obj0 = 0 ;
9280 char * kwnames[] = {
9281 (char *) "p", NULL
9282 };
9283
9284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9285 arg1 = obj0;
9286 {
9287 PyThreadState* __tstate = wxPyBeginAllowThreads();
9288 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9293 return resultobj;
9294 fail:
9295 return NULL;
9296 }
9297
9298
9299 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9300 PyObject *resultobj = 0;
9301 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9302 void *argp1 = 0 ;
9303 int res1 = 0 ;
9304 PyObject *swig_obj[1] ;
9305
9306 if (!args) SWIG_fail;
9307 swig_obj[0] = args;
9308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9309 if (!SWIG_IsOK(res1)) {
9310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9311 }
9312 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9313 {
9314 PyThreadState* __tstate = wxPyBeginAllowThreads();
9315 delete arg1;
9316
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_Py_Void();
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *resultobj = 0;
9329 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9330 void *argp1 = 0 ;
9331 int res1 = 0 ;
9332 PyObject *swig_obj[1] ;
9333
9334 if (!args) SWIG_fail;
9335 swig_obj[0] = args;
9336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9337 if (!SWIG_IsOK(res1)) {
9338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9339 }
9340 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 (arg1)->close();
9344 wxPyEndAllowThreads(__tstate);
9345 if (PyErr_Occurred()) SWIG_fail;
9346 }
9347 resultobj = SWIG_Py_Void();
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9355 PyObject *resultobj = 0;
9356 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9357 void *argp1 = 0 ;
9358 int res1 = 0 ;
9359 PyObject *swig_obj[1] ;
9360
9361 if (!args) SWIG_fail;
9362 swig_obj[0] = args;
9363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9364 if (!SWIG_IsOK(res1)) {
9365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9366 }
9367 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 (arg1)->flush();
9371 wxPyEndAllowThreads(__tstate);
9372 if (PyErr_Occurred()) SWIG_fail;
9373 }
9374 resultobj = SWIG_Py_Void();
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9382 PyObject *resultobj = 0;
9383 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9384 bool result;
9385 void *argp1 = 0 ;
9386 int res1 = 0 ;
9387 PyObject *swig_obj[1] ;
9388
9389 if (!args) SWIG_fail;
9390 swig_obj[0] = args;
9391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9392 if (!SWIG_IsOK(res1)) {
9393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9394 }
9395 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9396 {
9397 PyThreadState* __tstate = wxPyBeginAllowThreads();
9398 result = (bool)(arg1)->eof();
9399 wxPyEndAllowThreads(__tstate);
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 {
9403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9404 }
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9412 PyObject *resultobj = 0;
9413 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9414 int arg2 = (int) -1 ;
9415 PyObject *result = 0 ;
9416 void *argp1 = 0 ;
9417 int res1 = 0 ;
9418 int val2 ;
9419 int ecode2 = 0 ;
9420 PyObject * obj0 = 0 ;
9421 PyObject * obj1 = 0 ;
9422 char * kwnames[] = {
9423 (char *) "self",(char *) "size", NULL
9424 };
9425
9426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9428 if (!SWIG_IsOK(res1)) {
9429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9430 }
9431 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9432 if (obj1) {
9433 ecode2 = SWIG_AsVal_int(obj1, &val2);
9434 if (!SWIG_IsOK(ecode2)) {
9435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9436 }
9437 arg2 = static_cast< int >(val2);
9438 }
9439 {
9440 PyThreadState* __tstate = wxPyBeginAllowThreads();
9441 result = (PyObject *)(arg1)->read(arg2);
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 resultobj = result;
9446 return resultobj;
9447 fail:
9448 return NULL;
9449 }
9450
9451
9452 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj = 0;
9454 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9455 int arg2 = (int) -1 ;
9456 PyObject *result = 0 ;
9457 void *argp1 = 0 ;
9458 int res1 = 0 ;
9459 int val2 ;
9460 int ecode2 = 0 ;
9461 PyObject * obj0 = 0 ;
9462 PyObject * obj1 = 0 ;
9463 char * kwnames[] = {
9464 (char *) "self",(char *) "size", NULL
9465 };
9466
9467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9471 }
9472 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9473 if (obj1) {
9474 ecode2 = SWIG_AsVal_int(obj1, &val2);
9475 if (!SWIG_IsOK(ecode2)) {
9476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9477 }
9478 arg2 = static_cast< int >(val2);
9479 }
9480 {
9481 PyThreadState* __tstate = wxPyBeginAllowThreads();
9482 result = (PyObject *)(arg1)->readline(arg2);
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 resultobj = result;
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9494 PyObject *resultobj = 0;
9495 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9496 int arg2 = (int) -1 ;
9497 PyObject *result = 0 ;
9498 void *argp1 = 0 ;
9499 int res1 = 0 ;
9500 int val2 ;
9501 int ecode2 = 0 ;
9502 PyObject * obj0 = 0 ;
9503 PyObject * obj1 = 0 ;
9504 char * kwnames[] = {
9505 (char *) "self",(char *) "sizehint", NULL
9506 };
9507
9508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9510 if (!SWIG_IsOK(res1)) {
9511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9512 }
9513 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9514 if (obj1) {
9515 ecode2 = SWIG_AsVal_int(obj1, &val2);
9516 if (!SWIG_IsOK(ecode2)) {
9517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9518 }
9519 arg2 = static_cast< int >(val2);
9520 }
9521 {
9522 PyThreadState* __tstate = wxPyBeginAllowThreads();
9523 result = (PyObject *)(arg1)->readlines(arg2);
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 resultobj = result;
9528 return resultobj;
9529 fail:
9530 return NULL;
9531 }
9532
9533
9534 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9535 PyObject *resultobj = 0;
9536 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9537 int arg2 ;
9538 int arg3 = (int) 0 ;
9539 void *argp1 = 0 ;
9540 int res1 = 0 ;
9541 int val2 ;
9542 int ecode2 = 0 ;
9543 int val3 ;
9544 int ecode3 = 0 ;
9545 PyObject * obj0 = 0 ;
9546 PyObject * obj1 = 0 ;
9547 PyObject * obj2 = 0 ;
9548 char * kwnames[] = {
9549 (char *) "self",(char *) "offset",(char *) "whence", NULL
9550 };
9551
9552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9554 if (!SWIG_IsOK(res1)) {
9555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9556 }
9557 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9558 ecode2 = SWIG_AsVal_int(obj1, &val2);
9559 if (!SWIG_IsOK(ecode2)) {
9560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9561 }
9562 arg2 = static_cast< int >(val2);
9563 if (obj2) {
9564 ecode3 = SWIG_AsVal_int(obj2, &val3);
9565 if (!SWIG_IsOK(ecode3)) {
9566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9567 }
9568 arg3 = static_cast< int >(val3);
9569 }
9570 {
9571 PyThreadState* __tstate = wxPyBeginAllowThreads();
9572 (arg1)->seek(arg2,arg3);
9573 wxPyEndAllowThreads(__tstate);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_Py_Void();
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9584 PyObject *resultobj = 0;
9585 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9586 int result;
9587 void *argp1 = 0 ;
9588 int res1 = 0 ;
9589 PyObject *swig_obj[1] ;
9590
9591 if (!args) SWIG_fail;
9592 swig_obj[0] = args;
9593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9594 if (!SWIG_IsOK(res1)) {
9595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9596 }
9597 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9598 {
9599 PyThreadState* __tstate = wxPyBeginAllowThreads();
9600 result = (int)(arg1)->tell();
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 resultobj = SWIG_From_int(static_cast< int >(result));
9605 return resultobj;
9606 fail:
9607 return NULL;
9608 }
9609
9610
9611 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9612 PyObject *resultobj = 0;
9613 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9614 char result;
9615 void *argp1 = 0 ;
9616 int res1 = 0 ;
9617 PyObject *swig_obj[1] ;
9618
9619 if (!args) SWIG_fail;
9620 swig_obj[0] = args;
9621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9622 if (!SWIG_IsOK(res1)) {
9623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9624 }
9625 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9626 {
9627 PyThreadState* __tstate = wxPyBeginAllowThreads();
9628 result = (char)(arg1)->Peek();
9629 wxPyEndAllowThreads(__tstate);
9630 if (PyErr_Occurred()) SWIG_fail;
9631 }
9632 resultobj = SWIG_From_char(static_cast< char >(result));
9633 return resultobj;
9634 fail:
9635 return NULL;
9636 }
9637
9638
9639 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9640 PyObject *resultobj = 0;
9641 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9642 char result;
9643 void *argp1 = 0 ;
9644 int res1 = 0 ;
9645 PyObject *swig_obj[1] ;
9646
9647 if (!args) SWIG_fail;
9648 swig_obj[0] = args;
9649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9650 if (!SWIG_IsOK(res1)) {
9651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9652 }
9653 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 result = (char)(arg1)->GetC();
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_From_char(static_cast< char >(result));
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9668 PyObject *resultobj = 0;
9669 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9670 size_t result;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 PyObject *swig_obj[1] ;
9674
9675 if (!args) SWIG_fail;
9676 swig_obj[0] = args;
9677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9678 if (!SWIG_IsOK(res1)) {
9679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9680 }
9681 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 result = (size_t)(arg1)->LastRead();
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696 PyObject *resultobj = 0;
9697 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9698 bool result;
9699 void *argp1 = 0 ;
9700 int res1 = 0 ;
9701 PyObject *swig_obj[1] ;
9702
9703 if (!args) SWIG_fail;
9704 swig_obj[0] = args;
9705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9706 if (!SWIG_IsOK(res1)) {
9707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9708 }
9709 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 result = (bool)(arg1)->CanRead();
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 {
9717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9718 }
9719 return resultobj;
9720 fail:
9721 return NULL;
9722 }
9723
9724
9725 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9726 PyObject *resultobj = 0;
9727 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9728 bool result;
9729 void *argp1 = 0 ;
9730 int res1 = 0 ;
9731 PyObject *swig_obj[1] ;
9732
9733 if (!args) SWIG_fail;
9734 swig_obj[0] = args;
9735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9736 if (!SWIG_IsOK(res1)) {
9737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9738 }
9739 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9740 {
9741 PyThreadState* __tstate = wxPyBeginAllowThreads();
9742 result = (bool)(arg1)->Eof();
9743 wxPyEndAllowThreads(__tstate);
9744 if (PyErr_Occurred()) SWIG_fail;
9745 }
9746 {
9747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9748 }
9749 return resultobj;
9750 fail:
9751 return NULL;
9752 }
9753
9754
9755 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9756 PyObject *resultobj = 0;
9757 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9758 char arg2 ;
9759 bool result;
9760 void *argp1 = 0 ;
9761 int res1 = 0 ;
9762 char val2 ;
9763 int ecode2 = 0 ;
9764 PyObject * obj0 = 0 ;
9765 PyObject * obj1 = 0 ;
9766 char * kwnames[] = {
9767 (char *) "self",(char *) "c", NULL
9768 };
9769
9770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9772 if (!SWIG_IsOK(res1)) {
9773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9774 }
9775 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9776 ecode2 = SWIG_AsVal_char(obj1, &val2);
9777 if (!SWIG_IsOK(ecode2)) {
9778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9779 }
9780 arg2 = static_cast< char >(val2);
9781 {
9782 PyThreadState* __tstate = wxPyBeginAllowThreads();
9783 result = (bool)(arg1)->Ungetch(arg2);
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 {
9788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9789 }
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9797 PyObject *resultobj = 0;
9798 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9799 long arg2 ;
9800 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9801 long result;
9802 void *argp1 = 0 ;
9803 int res1 = 0 ;
9804 long val2 ;
9805 int ecode2 = 0 ;
9806 int val3 ;
9807 int ecode3 = 0 ;
9808 PyObject * obj0 = 0 ;
9809 PyObject * obj1 = 0 ;
9810 PyObject * obj2 = 0 ;
9811 char * kwnames[] = {
9812 (char *) "self",(char *) "pos",(char *) "mode", NULL
9813 };
9814
9815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9819 }
9820 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9821 ecode2 = SWIG_AsVal_long(obj1, &val2);
9822 if (!SWIG_IsOK(ecode2)) {
9823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9824 }
9825 arg2 = static_cast< long >(val2);
9826 if (obj2) {
9827 ecode3 = SWIG_AsVal_int(obj2, &val3);
9828 if (!SWIG_IsOK(ecode3)) {
9829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9830 }
9831 arg3 = static_cast< wxSeekMode >(val3);
9832 }
9833 {
9834 PyThreadState* __tstate = wxPyBeginAllowThreads();
9835 result = (long)(arg1)->SeekI(arg2,arg3);
9836 wxPyEndAllowThreads(__tstate);
9837 if (PyErr_Occurred()) SWIG_fail;
9838 }
9839 resultobj = SWIG_From_long(static_cast< long >(result));
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 PyObject *resultobj = 0;
9848 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9849 long result;
9850 void *argp1 = 0 ;
9851 int res1 = 0 ;
9852 PyObject *swig_obj[1] ;
9853
9854 if (!args) SWIG_fail;
9855 swig_obj[0] = args;
9856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9857 if (!SWIG_IsOK(res1)) {
9858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9859 }
9860 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9861 {
9862 PyThreadState* __tstate = wxPyBeginAllowThreads();
9863 result = (long)(arg1)->TellI();
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 resultobj = SWIG_From_long(static_cast< long >(result));
9868 return resultobj;
9869 fail:
9870 return NULL;
9871 }
9872
9873
9874 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9875 PyObject *obj;
9876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9877 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9878 return SWIG_Py_Void();
9879 }
9880
9881 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9882 return SWIG_Python_InitShadowInstance(args);
9883 }
9884
9885 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9886 PyObject *resultobj = 0;
9887 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9888 PyObject *arg2 = (PyObject *) 0 ;
9889 void *argp1 = 0 ;
9890 int res1 = 0 ;
9891 PyObject * obj0 = 0 ;
9892 PyObject * obj1 = 0 ;
9893 char * kwnames[] = {
9894 (char *) "self",(char *) "obj", NULL
9895 };
9896
9897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9899 if (!SWIG_IsOK(res1)) {
9900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9901 }
9902 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9903 arg2 = obj1;
9904 {
9905 PyThreadState* __tstate = wxPyBeginAllowThreads();
9906 wxOutputStream_write(arg1,arg2);
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_Py_Void();
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *resultobj = 0;
9919 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9920 size_t result;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 PyObject *swig_obj[1] ;
9924
9925 if (!args) SWIG_fail;
9926 swig_obj[0] = args;
9927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9930 }
9931 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9946 PyObject *obj;
9947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9948 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9949 return SWIG_Py_Void();
9950 }
9951
9952 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxInputStream *arg1 = (wxInputStream *) 0 ;
9955 wxString *arg2 = 0 ;
9956 wxString *arg3 = 0 ;
9957 wxString *arg4 = 0 ;
9958 wxDateTime arg5 ;
9959 wxFSFile *result = 0 ;
9960 wxPyInputStream *temp1 ;
9961 bool temp2 = false ;
9962 bool temp3 = false ;
9963 bool temp4 = false ;
9964 void *argp5 ;
9965 int res5 = 0 ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 PyObject * obj2 = 0 ;
9969 PyObject * obj3 = 0 ;
9970 PyObject * obj4 = 0 ;
9971 char * kwnames[] = {
9972 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9973 };
9974
9975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9976 {
9977 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9978 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9979 } else {
9980 PyErr_Clear(); // clear the failure of the wxPyConvert above
9981 arg1 = wxPyCBInputStream_create(obj0, true);
9982 if (arg1 == NULL) {
9983 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9984 SWIG_fail;
9985 }
9986 }
9987 }
9988 {
9989 arg2 = wxString_in_helper(obj1);
9990 if (arg2 == NULL) SWIG_fail;
9991 temp2 = true;
9992 }
9993 {
9994 arg3 = wxString_in_helper(obj2);
9995 if (arg3 == NULL) SWIG_fail;
9996 temp3 = true;
9997 }
9998 {
9999 arg4 = wxString_in_helper(obj3);
10000 if (arg4 == NULL) SWIG_fail;
10001 temp4 = true;
10002 }
10003 {
10004 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
10005 if (!SWIG_IsOK(res5)) {
10006 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10007 }
10008 if (!argp5) {
10009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10010 } else {
10011 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
10012 arg5 = *temp;
10013 if (SWIG_IsNewObj(res5)) delete temp;
10014 }
10015 }
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10023 {
10024 if (temp2)
10025 delete arg2;
10026 }
10027 {
10028 if (temp3)
10029 delete arg3;
10030 }
10031 {
10032 if (temp4)
10033 delete arg4;
10034 }
10035 return resultobj;
10036 fail:
10037 {
10038 if (temp2)
10039 delete arg2;
10040 }
10041 {
10042 if (temp3)
10043 delete arg3;
10044 }
10045 {
10046 if (temp4)
10047 delete arg4;
10048 }
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10054 PyObject *resultobj = 0;
10055 wxFSFile *arg1 = (wxFSFile *) 0 ;
10056 void *argp1 = 0 ;
10057 int res1 = 0 ;
10058 PyObject *swig_obj[1] ;
10059
10060 if (!args) SWIG_fail;
10061 swig_obj[0] = args;
10062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10063 if (!SWIG_IsOK(res1)) {
10064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10065 }
10066 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10067 {
10068 PyThreadState* __tstate = wxPyBeginAllowThreads();
10069 delete arg1;
10070
10071 wxPyEndAllowThreads(__tstate);
10072 if (PyErr_Occurred()) SWIG_fail;
10073 }
10074 resultobj = SWIG_Py_Void();
10075 return resultobj;
10076 fail:
10077 return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10082 PyObject *resultobj = 0;
10083 wxFSFile *arg1 = (wxFSFile *) 0 ;
10084 wxInputStream *result = 0 ;
10085 void *argp1 = 0 ;
10086 int res1 = 0 ;
10087 PyObject *swig_obj[1] ;
10088
10089 if (!args) SWIG_fail;
10090 swig_obj[0] = args;
10091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10092 if (!SWIG_IsOK(res1)) {
10093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10094 }
10095 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10096 {
10097 PyThreadState* __tstate = wxPyBeginAllowThreads();
10098 result = (wxInputStream *)(arg1)->GetStream();
10099 wxPyEndAllowThreads(__tstate);
10100 if (PyErr_Occurred()) SWIG_fail;
10101 }
10102 {
10103 wxPyInputStream * _ptr = NULL;
10104
10105 if (result) {
10106 _ptr = new wxPyInputStream(result);
10107 }
10108 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10109 }
10110 return resultobj;
10111 fail:
10112 return NULL;
10113 }
10114
10115
10116 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10117 PyObject *resultobj = 0;
10118 wxFSFile *arg1 = (wxFSFile *) 0 ;
10119 void *argp1 = 0 ;
10120 int res1 = 0 ;
10121 PyObject *swig_obj[1] ;
10122
10123 if (!args) SWIG_fail;
10124 swig_obj[0] = args;
10125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10126 if (!SWIG_IsOK(res1)) {
10127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10128 }
10129 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10130 {
10131 PyThreadState* __tstate = wxPyBeginAllowThreads();
10132 (arg1)->DetachStream();
10133 wxPyEndAllowThreads(__tstate);
10134 if (PyErr_Occurred()) SWIG_fail;
10135 }
10136 resultobj = SWIG_Py_Void();
10137 return resultobj;
10138 fail:
10139 return NULL;
10140 }
10141
10142
10143 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10144 PyObject *resultobj = 0;
10145 wxFSFile *arg1 = (wxFSFile *) 0 ;
10146 wxString *result = 0 ;
10147 void *argp1 = 0 ;
10148 int res1 = 0 ;
10149 PyObject *swig_obj[1] ;
10150
10151 if (!args) SWIG_fail;
10152 swig_obj[0] = args;
10153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10154 if (!SWIG_IsOK(res1)) {
10155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10156 }
10157 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 {
10161 wxString const &_result_ref = (arg1)->GetMimeType();
10162 result = (wxString *) &_result_ref;
10163 }
10164 wxPyEndAllowThreads(__tstate);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 {
10168 #if wxUSE_UNICODE
10169 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10170 #else
10171 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10172 #endif
10173 }
10174 return resultobj;
10175 fail:
10176 return NULL;
10177 }
10178
10179
10180 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10181 PyObject *resultobj = 0;
10182 wxFSFile *arg1 = (wxFSFile *) 0 ;
10183 wxString *result = 0 ;
10184 void *argp1 = 0 ;
10185 int res1 = 0 ;
10186 PyObject *swig_obj[1] ;
10187
10188 if (!args) SWIG_fail;
10189 swig_obj[0] = args;
10190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10191 if (!SWIG_IsOK(res1)) {
10192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10193 }
10194 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10195 {
10196 PyThreadState* __tstate = wxPyBeginAllowThreads();
10197 {
10198 wxString const &_result_ref = (arg1)->GetLocation();
10199 result = (wxString *) &_result_ref;
10200 }
10201 wxPyEndAllowThreads(__tstate);
10202 if (PyErr_Occurred()) SWIG_fail;
10203 }
10204 {
10205 #if wxUSE_UNICODE
10206 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10207 #else
10208 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10209 #endif
10210 }
10211 return resultobj;
10212 fail:
10213 return NULL;
10214 }
10215
10216
10217 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10218 PyObject *resultobj = 0;
10219 wxFSFile *arg1 = (wxFSFile *) 0 ;
10220 wxString *result = 0 ;
10221 void *argp1 = 0 ;
10222 int res1 = 0 ;
10223 PyObject *swig_obj[1] ;
10224
10225 if (!args) SWIG_fail;
10226 swig_obj[0] = args;
10227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10228 if (!SWIG_IsOK(res1)) {
10229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10230 }
10231 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10232 {
10233 PyThreadState* __tstate = wxPyBeginAllowThreads();
10234 {
10235 wxString const &_result_ref = (arg1)->GetAnchor();
10236 result = (wxString *) &_result_ref;
10237 }
10238 wxPyEndAllowThreads(__tstate);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 {
10242 #if wxUSE_UNICODE
10243 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10244 #else
10245 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10246 #endif
10247 }
10248 return resultobj;
10249 fail:
10250 return NULL;
10251 }
10252
10253
10254 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10255 PyObject *resultobj = 0;
10256 wxFSFile *arg1 = (wxFSFile *) 0 ;
10257 wxDateTime result;
10258 void *argp1 = 0 ;
10259 int res1 = 0 ;
10260 PyObject *swig_obj[1] ;
10261
10262 if (!args) SWIG_fail;
10263 swig_obj[0] = args;
10264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10267 }
10268 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 result = (arg1)->GetModificationTime();
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10276 return resultobj;
10277 fail:
10278 return NULL;
10279 }
10280
10281
10282 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10283 PyObject *obj;
10284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10285 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10286 return SWIG_Py_Void();
10287 }
10288
10289 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10290 return SWIG_Python_InitShadowInstance(args);
10291 }
10292
10293 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10294 PyObject *resultobj = 0;
10295 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10296 void *argp1 = 0 ;
10297 int res1 = 0 ;
10298 PyObject *swig_obj[1] ;
10299
10300 if (!args) SWIG_fail;
10301 swig_obj[0] = args;
10302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10305 }
10306 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10307 {
10308 PyThreadState* __tstate = wxPyBeginAllowThreads();
10309 delete arg1;
10310
10311 wxPyEndAllowThreads(__tstate);
10312 if (PyErr_Occurred()) SWIG_fail;
10313 }
10314 resultobj = SWIG_Py_Void();
10315 return resultobj;
10316 fail:
10317 return NULL;
10318 }
10319
10320
10321 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10322 PyObject *obj;
10323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10324 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10325 return SWIG_Py_Void();
10326 }
10327
10328 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10329 PyObject *resultobj = 0;
10330 wxPyFileSystemHandler *result = 0 ;
10331
10332 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10333 {
10334 PyThreadState* __tstate = wxPyBeginAllowThreads();
10335 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10336 wxPyEndAllowThreads(__tstate);
10337 if (PyErr_Occurred()) SWIG_fail;
10338 }
10339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10340 return resultobj;
10341 fail:
10342 return NULL;
10343 }
10344
10345
10346 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10347 PyObject *resultobj = 0;
10348 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10349 PyObject *arg2 = (PyObject *) 0 ;
10350 PyObject *arg3 = (PyObject *) 0 ;
10351 void *argp1 = 0 ;
10352 int res1 = 0 ;
10353 PyObject * obj0 = 0 ;
10354 PyObject * obj1 = 0 ;
10355 PyObject * obj2 = 0 ;
10356 char * kwnames[] = {
10357 (char *) "self",(char *) "self",(char *) "_class", NULL
10358 };
10359
10360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10362 if (!SWIG_IsOK(res1)) {
10363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10364 }
10365 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10366 arg2 = obj1;
10367 arg3 = obj2;
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 (arg1)->_setCallbackInfo(arg2,arg3);
10371 wxPyEndAllowThreads(__tstate);
10372 if (PyErr_Occurred()) SWIG_fail;
10373 }
10374 resultobj = SWIG_Py_Void();
10375 return resultobj;
10376 fail:
10377 return NULL;
10378 }
10379
10380
10381 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj = 0;
10383 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10384 wxString *arg2 = 0 ;
10385 bool result;
10386 void *argp1 = 0 ;
10387 int res1 = 0 ;
10388 bool temp2 = false ;
10389 PyObject * obj0 = 0 ;
10390 PyObject * obj1 = 0 ;
10391 char * kwnames[] = {
10392 (char *) "self",(char *) "location", NULL
10393 };
10394
10395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10397 if (!SWIG_IsOK(res1)) {
10398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10399 }
10400 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10401 {
10402 arg2 = wxString_in_helper(obj1);
10403 if (arg2 == NULL) SWIG_fail;
10404 temp2 = true;
10405 }
10406 {
10407 PyThreadState* __tstate = wxPyBeginAllowThreads();
10408 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10409 wxPyEndAllowThreads(__tstate);
10410 if (PyErr_Occurred()) SWIG_fail;
10411 }
10412 {
10413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10414 }
10415 {
10416 if (temp2)
10417 delete arg2;
10418 }
10419 return resultobj;
10420 fail:
10421 {
10422 if (temp2)
10423 delete arg2;
10424 }
10425 return NULL;
10426 }
10427
10428
10429 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10430 PyObject *resultobj = 0;
10431 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10432 wxFileSystem *arg2 = 0 ;
10433 wxString *arg3 = 0 ;
10434 wxFSFile *result = 0 ;
10435 void *argp1 = 0 ;
10436 int res1 = 0 ;
10437 void *argp2 = 0 ;
10438 int res2 = 0 ;
10439 bool temp3 = false ;
10440 PyObject * obj0 = 0 ;
10441 PyObject * obj1 = 0 ;
10442 PyObject * obj2 = 0 ;
10443 char * kwnames[] = {
10444 (char *) "self",(char *) "fs",(char *) "location", NULL
10445 };
10446
10447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10449 if (!SWIG_IsOK(res1)) {
10450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10451 }
10452 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10454 if (!SWIG_IsOK(res2)) {
10455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10456 }
10457 if (!argp2) {
10458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10459 }
10460 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10461 {
10462 arg3 = wxString_in_helper(obj2);
10463 if (arg3 == NULL) SWIG_fail;
10464 temp3 = true;
10465 }
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10474 }
10475 {
10476 if (temp3)
10477 delete arg3;
10478 }
10479 return resultobj;
10480 fail:
10481 {
10482 if (temp3)
10483 delete arg3;
10484 }
10485 return NULL;
10486 }
10487
10488
10489 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10490 PyObject *resultobj = 0;
10491 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10492 wxString *arg2 = 0 ;
10493 int arg3 = (int) 0 ;
10494 wxString result;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 bool temp2 = false ;
10498 int val3 ;
10499 int ecode3 = 0 ;
10500 PyObject * obj0 = 0 ;
10501 PyObject * obj1 = 0 ;
10502 PyObject * obj2 = 0 ;
10503 char * kwnames[] = {
10504 (char *) "self",(char *) "spec",(char *) "flags", NULL
10505 };
10506
10507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10509 if (!SWIG_IsOK(res1)) {
10510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10511 }
10512 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10513 {
10514 arg2 = wxString_in_helper(obj1);
10515 if (arg2 == NULL) SWIG_fail;
10516 temp2 = true;
10517 }
10518 if (obj2) {
10519 ecode3 = SWIG_AsVal_int(obj2, &val3);
10520 if (!SWIG_IsOK(ecode3)) {
10521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10522 }
10523 arg3 = static_cast< int >(val3);
10524 }
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 #if wxUSE_UNICODE
10533 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10534 #else
10535 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10536 #endif
10537 }
10538 {
10539 if (temp2)
10540 delete arg2;
10541 }
10542 return resultobj;
10543 fail:
10544 {
10545 if (temp2)
10546 delete arg2;
10547 }
10548 return NULL;
10549 }
10550
10551
10552 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10553 PyObject *resultobj = 0;
10554 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10555 wxString result;
10556 void *argp1 = 0 ;
10557 int res1 = 0 ;
10558 PyObject *swig_obj[1] ;
10559
10560 if (!args) SWIG_fail;
10561 swig_obj[0] = args;
10562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10563 if (!SWIG_IsOK(res1)) {
10564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10565 }
10566 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (arg1)->FindNext();
10570 wxPyEndAllowThreads(__tstate);
10571 if (PyErr_Occurred()) SWIG_fail;
10572 }
10573 {
10574 #if wxUSE_UNICODE
10575 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10576 #else
10577 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10578 #endif
10579 }
10580 return resultobj;
10581 fail:
10582 return NULL;
10583 }
10584
10585
10586 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10587 PyObject *resultobj = 0;
10588 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10589 wxString *arg2 = 0 ;
10590 wxString result;
10591 void *argp1 = 0 ;
10592 int res1 = 0 ;
10593 bool temp2 = false ;
10594 PyObject * obj0 = 0 ;
10595 PyObject * obj1 = 0 ;
10596 char * kwnames[] = {
10597 (char *) "self",(char *) "location", NULL
10598 };
10599
10600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10602 if (!SWIG_IsOK(res1)) {
10603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10604 }
10605 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10606 {
10607 arg2 = wxString_in_helper(obj1);
10608 if (arg2 == NULL) SWIG_fail;
10609 temp2 = true;
10610 }
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (arg1)->GetProtocol((wxString const &)*arg2);
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 #if wxUSE_UNICODE
10619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10620 #else
10621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10622 #endif
10623 }
10624 {
10625 if (temp2)
10626 delete arg2;
10627 }
10628 return resultobj;
10629 fail:
10630 {
10631 if (temp2)
10632 delete arg2;
10633 }
10634 return NULL;
10635 }
10636
10637
10638 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10639 PyObject *resultobj = 0;
10640 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10641 wxString *arg2 = 0 ;
10642 wxString result;
10643 void *argp1 = 0 ;
10644 int res1 = 0 ;
10645 bool temp2 = false ;
10646 PyObject * obj0 = 0 ;
10647 PyObject * obj1 = 0 ;
10648 char * kwnames[] = {
10649 (char *) "self",(char *) "location", NULL
10650 };
10651
10652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10654 if (!SWIG_IsOK(res1)) {
10655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10656 }
10657 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10658 {
10659 arg2 = wxString_in_helper(obj1);
10660 if (arg2 == NULL) SWIG_fail;
10661 temp2 = true;
10662 }
10663 {
10664 PyThreadState* __tstate = wxPyBeginAllowThreads();
10665 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10666 wxPyEndAllowThreads(__tstate);
10667 if (PyErr_Occurred()) SWIG_fail;
10668 }
10669 {
10670 #if wxUSE_UNICODE
10671 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10672 #else
10673 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10674 #endif
10675 }
10676 {
10677 if (temp2)
10678 delete arg2;
10679 }
10680 return resultobj;
10681 fail:
10682 {
10683 if (temp2)
10684 delete arg2;
10685 }
10686 return NULL;
10687 }
10688
10689
10690 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj = 0;
10692 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10693 wxString *arg2 = 0 ;
10694 wxString result;
10695 void *argp1 = 0 ;
10696 int res1 = 0 ;
10697 bool temp2 = false ;
10698 PyObject * obj0 = 0 ;
10699 PyObject * obj1 = 0 ;
10700 char * kwnames[] = {
10701 (char *) "self",(char *) "location", NULL
10702 };
10703
10704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10706 if (!SWIG_IsOK(res1)) {
10707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10708 }
10709 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10710 {
10711 arg2 = wxString_in_helper(obj1);
10712 if (arg2 == NULL) SWIG_fail;
10713 temp2 = true;
10714 }
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = (arg1)->GetAnchor((wxString const &)*arg2);
10718 wxPyEndAllowThreads(__tstate);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 {
10722 #if wxUSE_UNICODE
10723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10724 #else
10725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10726 #endif
10727 }
10728 {
10729 if (temp2)
10730 delete arg2;
10731 }
10732 return resultobj;
10733 fail:
10734 {
10735 if (temp2)
10736 delete arg2;
10737 }
10738 return NULL;
10739 }
10740
10741
10742 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10743 PyObject *resultobj = 0;
10744 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10745 wxString *arg2 = 0 ;
10746 wxString result;
10747 void *argp1 = 0 ;
10748 int res1 = 0 ;
10749 bool temp2 = false ;
10750 PyObject * obj0 = 0 ;
10751 PyObject * obj1 = 0 ;
10752 char * kwnames[] = {
10753 (char *) "self",(char *) "location", NULL
10754 };
10755
10756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10758 if (!SWIG_IsOK(res1)) {
10759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10760 }
10761 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10762 {
10763 arg2 = wxString_in_helper(obj1);
10764 if (arg2 == NULL) SWIG_fail;
10765 temp2 = true;
10766 }
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10770 wxPyEndAllowThreads(__tstate);
10771 if (PyErr_Occurred()) SWIG_fail;
10772 }
10773 {
10774 #if wxUSE_UNICODE
10775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10776 #else
10777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10778 #endif
10779 }
10780 {
10781 if (temp2)
10782 delete arg2;
10783 }
10784 return resultobj;
10785 fail:
10786 {
10787 if (temp2)
10788 delete arg2;
10789 }
10790 return NULL;
10791 }
10792
10793
10794 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10795 PyObject *resultobj = 0;
10796 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10797 wxString *arg2 = 0 ;
10798 wxString result;
10799 void *argp1 = 0 ;
10800 int res1 = 0 ;
10801 bool temp2 = false ;
10802 PyObject * obj0 = 0 ;
10803 PyObject * obj1 = 0 ;
10804 char * kwnames[] = {
10805 (char *) "self",(char *) "location", NULL
10806 };
10807
10808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10810 if (!SWIG_IsOK(res1)) {
10811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10812 }
10813 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10814 {
10815 arg2 = wxString_in_helper(obj1);
10816 if (arg2 == NULL) SWIG_fail;
10817 temp2 = true;
10818 }
10819 {
10820 PyThreadState* __tstate = wxPyBeginAllowThreads();
10821 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10822 wxPyEndAllowThreads(__tstate);
10823 if (PyErr_Occurred()) SWIG_fail;
10824 }
10825 {
10826 #if wxUSE_UNICODE
10827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10828 #else
10829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10830 #endif
10831 }
10832 {
10833 if (temp2)
10834 delete arg2;
10835 }
10836 return resultobj;
10837 fail:
10838 {
10839 if (temp2)
10840 delete arg2;
10841 }
10842 return NULL;
10843 }
10844
10845
10846 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10847 PyObject *obj;
10848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10849 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10850 return SWIG_Py_Void();
10851 }
10852
10853 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10854 return SWIG_Python_InitShadowInstance(args);
10855 }
10856
10857 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10858 PyObject *resultobj = 0;
10859 wxFileSystem *result = 0 ;
10860
10861 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10862 {
10863 PyThreadState* __tstate = wxPyBeginAllowThreads();
10864 result = (wxFileSystem *)new wxFileSystem();
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10876 PyObject *resultobj = 0;
10877 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10878 void *argp1 = 0 ;
10879 int res1 = 0 ;
10880 PyObject *swig_obj[1] ;
10881
10882 if (!args) SWIG_fail;
10883 swig_obj[0] = args;
10884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10885 if (!SWIG_IsOK(res1)) {
10886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10887 }
10888 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 delete arg1;
10892
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_Py_Void();
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj = 0;
10905 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10906 wxString *arg2 = 0 ;
10907 bool arg3 = (bool) false ;
10908 void *argp1 = 0 ;
10909 int res1 = 0 ;
10910 bool temp2 = false ;
10911 bool val3 ;
10912 int ecode3 = 0 ;
10913 PyObject * obj0 = 0 ;
10914 PyObject * obj1 = 0 ;
10915 PyObject * obj2 = 0 ;
10916 char * kwnames[] = {
10917 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10918 };
10919
10920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10922 if (!SWIG_IsOK(res1)) {
10923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10924 }
10925 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10926 {
10927 arg2 = wxString_in_helper(obj1);
10928 if (arg2 == NULL) SWIG_fail;
10929 temp2 = true;
10930 }
10931 if (obj2) {
10932 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10933 if (!SWIG_IsOK(ecode3)) {
10934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10935 }
10936 arg3 = static_cast< bool >(val3);
10937 }
10938 {
10939 PyThreadState* __tstate = wxPyBeginAllowThreads();
10940 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10941 wxPyEndAllowThreads(__tstate);
10942 if (PyErr_Occurred()) SWIG_fail;
10943 }
10944 resultobj = SWIG_Py_Void();
10945 {
10946 if (temp2)
10947 delete arg2;
10948 }
10949 return resultobj;
10950 fail:
10951 {
10952 if (temp2)
10953 delete arg2;
10954 }
10955 return NULL;
10956 }
10957
10958
10959 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10960 PyObject *resultobj = 0;
10961 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10962 wxString result;
10963 void *argp1 = 0 ;
10964 int res1 = 0 ;
10965 PyObject *swig_obj[1] ;
10966
10967 if (!args) SWIG_fail;
10968 swig_obj[0] = args;
10969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10970 if (!SWIG_IsOK(res1)) {
10971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10972 }
10973 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10974 {
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 result = (arg1)->GetPath();
10977 wxPyEndAllowThreads(__tstate);
10978 if (PyErr_Occurred()) SWIG_fail;
10979 }
10980 {
10981 #if wxUSE_UNICODE
10982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10983 #else
10984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10985 #endif
10986 }
10987 return resultobj;
10988 fail:
10989 return NULL;
10990 }
10991
10992
10993 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10994 PyObject *resultobj = 0;
10995 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10996 wxString *arg2 = 0 ;
10997 wxFSFile *result = 0 ;
10998 void *argp1 = 0 ;
10999 int res1 = 0 ;
11000 bool temp2 = false ;
11001 PyObject * obj0 = 0 ;
11002 PyObject * obj1 = 0 ;
11003 char * kwnames[] = {
11004 (char *) "self",(char *) "location", NULL
11005 };
11006
11007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
11008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11009 if (!SWIG_IsOK(res1)) {
11010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11011 }
11012 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11013 {
11014 arg2 = wxString_in_helper(obj1);
11015 if (arg2 == NULL) SWIG_fail;
11016 temp2 = true;
11017 }
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11021 wxPyEndAllowThreads(__tstate);
11022 if (PyErr_Occurred()) SWIG_fail;
11023 }
11024 {
11025 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11026 }
11027 {
11028 if (temp2)
11029 delete arg2;
11030 }
11031 return resultobj;
11032 fail:
11033 {
11034 if (temp2)
11035 delete arg2;
11036 }
11037 return NULL;
11038 }
11039
11040
11041 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj = 0;
11043 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11044 wxString *arg2 = 0 ;
11045 int arg3 = (int) 0 ;
11046 wxString result;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 bool temp2 = false ;
11050 int val3 ;
11051 int ecode3 = 0 ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 PyObject * obj2 = 0 ;
11055 char * kwnames[] = {
11056 (char *) "self",(char *) "spec",(char *) "flags", NULL
11057 };
11058
11059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11061 if (!SWIG_IsOK(res1)) {
11062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11063 }
11064 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11065 {
11066 arg2 = wxString_in_helper(obj1);
11067 if (arg2 == NULL) SWIG_fail;
11068 temp2 = true;
11069 }
11070 if (obj2) {
11071 ecode3 = SWIG_AsVal_int(obj2, &val3);
11072 if (!SWIG_IsOK(ecode3)) {
11073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11074 }
11075 arg3 = static_cast< int >(val3);
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 #if wxUSE_UNICODE
11085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11086 #else
11087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11088 #endif
11089 }
11090 {
11091 if (temp2)
11092 delete arg2;
11093 }
11094 return resultobj;
11095 fail:
11096 {
11097 if (temp2)
11098 delete arg2;
11099 }
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11105 PyObject *resultobj = 0;
11106 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11107 wxString result;
11108 void *argp1 = 0 ;
11109 int res1 = 0 ;
11110 PyObject *swig_obj[1] ;
11111
11112 if (!args) SWIG_fail;
11113 swig_obj[0] = args;
11114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11117 }
11118 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11119 {
11120 PyThreadState* __tstate = wxPyBeginAllowThreads();
11121 result = (arg1)->FindNext();
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 {
11126 #if wxUSE_UNICODE
11127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11128 #else
11129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11130 #endif
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11139 PyObject *resultobj = 0;
11140 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11141 int res1 = 0 ;
11142 PyObject * obj0 = 0 ;
11143 char * kwnames[] = {
11144 (char *) "handler", NULL
11145 };
11146
11147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11148 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11149 if (!SWIG_IsOK(res1)) {
11150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11151 }
11152 {
11153 PyThreadState* __tstate = wxPyBeginAllowThreads();
11154 wxFileSystem::AddHandler(arg1);
11155 wxPyEndAllowThreads(__tstate);
11156 if (PyErr_Occurred()) SWIG_fail;
11157 }
11158 resultobj = SWIG_Py_Void();
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj = 0;
11167 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11168 wxFileSystemHandler *result = 0 ;
11169 void *argp1 = 0 ;
11170 int res1 = 0 ;
11171 PyObject * obj0 = 0 ;
11172 char * kwnames[] = {
11173 (char *) "handler", NULL
11174 };
11175
11176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11178 if (!SWIG_IsOK(res1)) {
11179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11180 }
11181 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11185 wxPyEndAllowThreads(__tstate);
11186 if (PyErr_Occurred()) SWIG_fail;
11187 }
11188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11196 PyObject *resultobj = 0;
11197
11198 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11199 {
11200 PyThreadState* __tstate = wxPyBeginAllowThreads();
11201 wxFileSystem::CleanUpHandlers();
11202 wxPyEndAllowThreads(__tstate);
11203 if (PyErr_Occurred()) SWIG_fail;
11204 }
11205 resultobj = SWIG_Py_Void();
11206 return resultobj;
11207 fail:
11208 return NULL;
11209 }
11210
11211
11212 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11213 PyObject *resultobj = 0;
11214 wxString *arg1 = 0 ;
11215 wxString result;
11216 bool temp1 = false ;
11217 PyObject * obj0 = 0 ;
11218 char * kwnames[] = {
11219 (char *) "filename", NULL
11220 };
11221
11222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11223 {
11224 arg1 = wxString_in_helper(obj0);
11225 if (arg1 == NULL) SWIG_fail;
11226 temp1 = true;
11227 }
11228 {
11229 PyThreadState* __tstate = wxPyBeginAllowThreads();
11230 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11231 wxPyEndAllowThreads(__tstate);
11232 if (PyErr_Occurred()) SWIG_fail;
11233 }
11234 {
11235 #if wxUSE_UNICODE
11236 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11237 #else
11238 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11239 #endif
11240 }
11241 {
11242 if (temp1)
11243 delete arg1;
11244 }
11245 return resultobj;
11246 fail:
11247 {
11248 if (temp1)
11249 delete arg1;
11250 }
11251 return NULL;
11252 }
11253
11254
11255 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11256 PyObject *resultobj = 0;
11257 wxString *arg1 = 0 ;
11258 wxString result;
11259 bool temp1 = false ;
11260 PyObject * obj0 = 0 ;
11261 char * kwnames[] = {
11262 (char *) "url", NULL
11263 };
11264
11265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11266 {
11267 arg1 = wxString_in_helper(obj0);
11268 if (arg1 == NULL) SWIG_fail;
11269 temp1 = true;
11270 }
11271 {
11272 PyThreadState* __tstate = wxPyBeginAllowThreads();
11273 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11274 wxPyEndAllowThreads(__tstate);
11275 if (PyErr_Occurred()) SWIG_fail;
11276 }
11277 {
11278 #if wxUSE_UNICODE
11279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11280 #else
11281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11282 #endif
11283 }
11284 {
11285 if (temp1)
11286 delete arg1;
11287 }
11288 return resultobj;
11289 fail:
11290 {
11291 if (temp1)
11292 delete arg1;
11293 }
11294 return NULL;
11295 }
11296
11297
11298 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11299 PyObject *obj;
11300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11301 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11302 return SWIG_Py_Void();
11303 }
11304
11305 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11306 return SWIG_Python_InitShadowInstance(args);
11307 }
11308
11309 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11310 PyObject *resultobj = 0;
11311 wxInternetFSHandler *result = 0 ;
11312
11313 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11314 {
11315 PyThreadState* __tstate = wxPyBeginAllowThreads();
11316 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11317 wxPyEndAllowThreads(__tstate);
11318 if (PyErr_Occurred()) SWIG_fail;
11319 }
11320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11321 return resultobj;
11322 fail:
11323 return NULL;
11324 }
11325
11326
11327 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11328 PyObject *resultobj = 0;
11329 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11330 wxString *arg2 = 0 ;
11331 bool result;
11332 void *argp1 = 0 ;
11333 int res1 = 0 ;
11334 bool temp2 = false ;
11335 PyObject * obj0 = 0 ;
11336 PyObject * obj1 = 0 ;
11337 char * kwnames[] = {
11338 (char *) "self",(char *) "location", NULL
11339 };
11340
11341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11343 if (!SWIG_IsOK(res1)) {
11344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11345 }
11346 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11347 {
11348 arg2 = wxString_in_helper(obj1);
11349 if (arg2 == NULL) SWIG_fail;
11350 temp2 = true;
11351 }
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11360 }
11361 {
11362 if (temp2)
11363 delete arg2;
11364 }
11365 return resultobj;
11366 fail:
11367 {
11368 if (temp2)
11369 delete arg2;
11370 }
11371 return NULL;
11372 }
11373
11374
11375 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11376 PyObject *resultobj = 0;
11377 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11378 wxFileSystem *arg2 = 0 ;
11379 wxString *arg3 = 0 ;
11380 wxFSFile *result = 0 ;
11381 void *argp1 = 0 ;
11382 int res1 = 0 ;
11383 void *argp2 = 0 ;
11384 int res2 = 0 ;
11385 bool temp3 = false ;
11386 PyObject * obj0 = 0 ;
11387 PyObject * obj1 = 0 ;
11388 PyObject * obj2 = 0 ;
11389 char * kwnames[] = {
11390 (char *) "self",(char *) "fs",(char *) "location", NULL
11391 };
11392
11393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11395 if (!SWIG_IsOK(res1)) {
11396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11397 }
11398 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11399 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11400 if (!SWIG_IsOK(res2)) {
11401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11402 }
11403 if (!argp2) {
11404 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11405 }
11406 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11407 {
11408 arg3 = wxString_in_helper(obj2);
11409 if (arg3 == NULL) SWIG_fail;
11410 temp3 = true;
11411 }
11412 {
11413 PyThreadState* __tstate = wxPyBeginAllowThreads();
11414 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11415 wxPyEndAllowThreads(__tstate);
11416 if (PyErr_Occurred()) SWIG_fail;
11417 }
11418 {
11419 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11420 }
11421 {
11422 if (temp3)
11423 delete arg3;
11424 }
11425 return resultobj;
11426 fail:
11427 {
11428 if (temp3)
11429 delete arg3;
11430 }
11431 return NULL;
11432 }
11433
11434
11435 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11436 PyObject *obj;
11437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11438 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11439 return SWIG_Py_Void();
11440 }
11441
11442 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11443 return SWIG_Python_InitShadowInstance(args);
11444 }
11445
11446 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11447 PyObject *resultobj = 0;
11448 wxZipFSHandler *result = 0 ;
11449
11450 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11451 {
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 result = (wxZipFSHandler *)new wxZipFSHandler();
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11458 return resultobj;
11459 fail:
11460 return NULL;
11461 }
11462
11463
11464 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj = 0;
11466 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11467 wxString *arg2 = 0 ;
11468 bool result;
11469 void *argp1 = 0 ;
11470 int res1 = 0 ;
11471 bool temp2 = false ;
11472 PyObject * obj0 = 0 ;
11473 PyObject * obj1 = 0 ;
11474 char * kwnames[] = {
11475 (char *) "self",(char *) "location", NULL
11476 };
11477
11478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11480 if (!SWIG_IsOK(res1)) {
11481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11482 }
11483 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11484 {
11485 arg2 = wxString_in_helper(obj1);
11486 if (arg2 == NULL) SWIG_fail;
11487 temp2 = true;
11488 }
11489 {
11490 PyThreadState* __tstate = wxPyBeginAllowThreads();
11491 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11492 wxPyEndAllowThreads(__tstate);
11493 if (PyErr_Occurred()) SWIG_fail;
11494 }
11495 {
11496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11497 }
11498 {
11499 if (temp2)
11500 delete arg2;
11501 }
11502 return resultobj;
11503 fail:
11504 {
11505 if (temp2)
11506 delete arg2;
11507 }
11508 return NULL;
11509 }
11510
11511
11512 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11513 PyObject *resultobj = 0;
11514 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11515 wxFileSystem *arg2 = 0 ;
11516 wxString *arg3 = 0 ;
11517 wxFSFile *result = 0 ;
11518 void *argp1 = 0 ;
11519 int res1 = 0 ;
11520 void *argp2 = 0 ;
11521 int res2 = 0 ;
11522 bool temp3 = false ;
11523 PyObject * obj0 = 0 ;
11524 PyObject * obj1 = 0 ;
11525 PyObject * obj2 = 0 ;
11526 char * kwnames[] = {
11527 (char *) "self",(char *) "fs",(char *) "location", NULL
11528 };
11529
11530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11532 if (!SWIG_IsOK(res1)) {
11533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11534 }
11535 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11537 if (!SWIG_IsOK(res2)) {
11538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11539 }
11540 if (!argp2) {
11541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11542 }
11543 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11544 {
11545 arg3 = wxString_in_helper(obj2);
11546 if (arg3 == NULL) SWIG_fail;
11547 temp3 = true;
11548 }
11549 {
11550 PyThreadState* __tstate = wxPyBeginAllowThreads();
11551 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11552 wxPyEndAllowThreads(__tstate);
11553 if (PyErr_Occurred()) SWIG_fail;
11554 }
11555 {
11556 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11557 }
11558 {
11559 if (temp3)
11560 delete arg3;
11561 }
11562 return resultobj;
11563 fail:
11564 {
11565 if (temp3)
11566 delete arg3;
11567 }
11568 return NULL;
11569 }
11570
11571
11572 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11573 PyObject *resultobj = 0;
11574 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11575 wxString *arg2 = 0 ;
11576 int arg3 = (int) 0 ;
11577 wxString result;
11578 void *argp1 = 0 ;
11579 int res1 = 0 ;
11580 bool temp2 = false ;
11581 int val3 ;
11582 int ecode3 = 0 ;
11583 PyObject * obj0 = 0 ;
11584 PyObject * obj1 = 0 ;
11585 PyObject * obj2 = 0 ;
11586 char * kwnames[] = {
11587 (char *) "self",(char *) "spec",(char *) "flags", NULL
11588 };
11589
11590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11592 if (!SWIG_IsOK(res1)) {
11593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11594 }
11595 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11596 {
11597 arg2 = wxString_in_helper(obj1);
11598 if (arg2 == NULL) SWIG_fail;
11599 temp2 = true;
11600 }
11601 if (obj2) {
11602 ecode3 = SWIG_AsVal_int(obj2, &val3);
11603 if (!SWIG_IsOK(ecode3)) {
11604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11605 }
11606 arg3 = static_cast< int >(val3);
11607 }
11608 {
11609 PyThreadState* __tstate = wxPyBeginAllowThreads();
11610 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 {
11615 #if wxUSE_UNICODE
11616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11617 #else
11618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11619 #endif
11620 }
11621 {
11622 if (temp2)
11623 delete arg2;
11624 }
11625 return resultobj;
11626 fail:
11627 {
11628 if (temp2)
11629 delete arg2;
11630 }
11631 return NULL;
11632 }
11633
11634
11635 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11636 PyObject *resultobj = 0;
11637 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11638 wxString result;
11639 void *argp1 = 0 ;
11640 int res1 = 0 ;
11641 PyObject *swig_obj[1] ;
11642
11643 if (!args) SWIG_fail;
11644 swig_obj[0] = args;
11645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11646 if (!SWIG_IsOK(res1)) {
11647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11648 }
11649 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11650 {
11651 PyThreadState* __tstate = wxPyBeginAllowThreads();
11652 result = (arg1)->FindNext();
11653 wxPyEndAllowThreads(__tstate);
11654 if (PyErr_Occurred()) SWIG_fail;
11655 }
11656 {
11657 #if wxUSE_UNICODE
11658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11659 #else
11660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11661 #endif
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11670 PyObject *obj;
11671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11672 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11673 return SWIG_Py_Void();
11674 }
11675
11676 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11677 return SWIG_Python_InitShadowInstance(args);
11678 }
11679
11680 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11681 PyObject *resultobj = 0;
11682 wxString *arg1 = 0 ;
11683 wxImage *arg2 = 0 ;
11684 long arg3 ;
11685 bool temp1 = false ;
11686 void *argp2 = 0 ;
11687 int res2 = 0 ;
11688 long val3 ;
11689 int ecode3 = 0 ;
11690 PyObject * obj0 = 0 ;
11691 PyObject * obj1 = 0 ;
11692 PyObject * obj2 = 0 ;
11693 char * kwnames[] = {
11694 (char *) "filename",(char *) "image",(char *) "type", NULL
11695 };
11696
11697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11698 {
11699 arg1 = wxString_in_helper(obj0);
11700 if (arg1 == NULL) SWIG_fail;
11701 temp1 = true;
11702 }
11703 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11704 if (!SWIG_IsOK(res2)) {
11705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11706 }
11707 if (!argp2) {
11708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11709 }
11710 arg2 = reinterpret_cast< wxImage * >(argp2);
11711 ecode3 = SWIG_AsVal_long(obj2, &val3);
11712 if (!SWIG_IsOK(ecode3)) {
11713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11714 }
11715 arg3 = static_cast< long >(val3);
11716 {
11717 PyThreadState* __tstate = wxPyBeginAllowThreads();
11718 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11719 wxPyEndAllowThreads(__tstate);
11720 if (PyErr_Occurred()) SWIG_fail;
11721 }
11722 resultobj = SWIG_Py_Void();
11723 {
11724 if (temp1)
11725 delete arg1;
11726 }
11727 return resultobj;
11728 fail:
11729 {
11730 if (temp1)
11731 delete arg1;
11732 }
11733 return NULL;
11734 }
11735
11736
11737 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11738 PyObject *resultobj = 0;
11739 wxString *arg1 = 0 ;
11740 wxBitmap *arg2 = 0 ;
11741 long arg3 ;
11742 bool temp1 = false ;
11743 void *argp2 = 0 ;
11744 int res2 = 0 ;
11745 long val3 ;
11746 int ecode3 = 0 ;
11747 PyObject * obj0 = 0 ;
11748 PyObject * obj1 = 0 ;
11749 PyObject * obj2 = 0 ;
11750 char * kwnames[] = {
11751 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11752 };
11753
11754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11755 {
11756 arg1 = wxString_in_helper(obj0);
11757 if (arg1 == NULL) SWIG_fail;
11758 temp1 = true;
11759 }
11760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11761 if (!SWIG_IsOK(res2)) {
11762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11763 }
11764 if (!argp2) {
11765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11766 }
11767 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11768 ecode3 = SWIG_AsVal_long(obj2, &val3);
11769 if (!SWIG_IsOK(ecode3)) {
11770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11771 }
11772 arg3 = static_cast< long >(val3);
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 resultobj = SWIG_Py_Void();
11780 {
11781 if (temp1)
11782 delete arg1;
11783 }
11784 return resultobj;
11785 fail:
11786 {
11787 if (temp1)
11788 delete arg1;
11789 }
11790 return NULL;
11791 }
11792
11793
11794 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11795 PyObject *resultobj = 0;
11796 wxString *arg1 = 0 ;
11797 PyObject *arg2 = (PyObject *) 0 ;
11798 bool temp1 = false ;
11799 PyObject * obj0 = 0 ;
11800 PyObject * obj1 = 0 ;
11801 char * kwnames[] = {
11802 (char *) "filename",(char *) "data", NULL
11803 };
11804
11805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11806 {
11807 arg1 = wxString_in_helper(obj0);
11808 if (arg1 == NULL) SWIG_fail;
11809 temp1 = true;
11810 }
11811 arg2 = obj1;
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11815 wxPyEndAllowThreads(__tstate);
11816 if (PyErr_Occurred()) SWIG_fail;
11817 }
11818 resultobj = SWIG_Py_Void();
11819 {
11820 if (temp1)
11821 delete arg1;
11822 }
11823 return resultobj;
11824 fail:
11825 {
11826 if (temp1)
11827 delete arg1;
11828 }
11829 return NULL;
11830 }
11831
11832
11833 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11834 PyObject *resultobj = 0;
11835 wxMemoryFSHandler *result = 0 ;
11836
11837 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11845 return resultobj;
11846 fail:
11847 return NULL;
11848 }
11849
11850
11851 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11852 PyObject *resultobj = 0;
11853 wxString *arg1 = 0 ;
11854 bool temp1 = false ;
11855 PyObject * obj0 = 0 ;
11856 char * kwnames[] = {
11857 (char *) "filename", NULL
11858 };
11859
11860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11861 {
11862 arg1 = wxString_in_helper(obj0);
11863 if (arg1 == NULL) SWIG_fail;
11864 temp1 = true;
11865 }
11866 {
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11869 wxPyEndAllowThreads(__tstate);
11870 if (PyErr_Occurred()) SWIG_fail;
11871 }
11872 resultobj = SWIG_Py_Void();
11873 {
11874 if (temp1)
11875 delete arg1;
11876 }
11877 return resultobj;
11878 fail:
11879 {
11880 if (temp1)
11881 delete arg1;
11882 }
11883 return NULL;
11884 }
11885
11886
11887 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj = 0;
11889 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11890 wxString *arg2 = 0 ;
11891 bool result;
11892 void *argp1 = 0 ;
11893 int res1 = 0 ;
11894 bool temp2 = false ;
11895 PyObject * obj0 = 0 ;
11896 PyObject * obj1 = 0 ;
11897 char * kwnames[] = {
11898 (char *) "self",(char *) "location", NULL
11899 };
11900
11901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11905 }
11906 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11907 {
11908 arg2 = wxString_in_helper(obj1);
11909 if (arg2 == NULL) SWIG_fail;
11910 temp2 = true;
11911 }
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11915 wxPyEndAllowThreads(__tstate);
11916 if (PyErr_Occurred()) SWIG_fail;
11917 }
11918 {
11919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11920 }
11921 {
11922 if (temp2)
11923 delete arg2;
11924 }
11925 return resultobj;
11926 fail:
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj = 0;
11937 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11938 wxFileSystem *arg2 = 0 ;
11939 wxString *arg3 = 0 ;
11940 wxFSFile *result = 0 ;
11941 void *argp1 = 0 ;
11942 int res1 = 0 ;
11943 void *argp2 = 0 ;
11944 int res2 = 0 ;
11945 bool temp3 = false ;
11946 PyObject * obj0 = 0 ;
11947 PyObject * obj1 = 0 ;
11948 PyObject * obj2 = 0 ;
11949 char * kwnames[] = {
11950 (char *) "self",(char *) "fs",(char *) "location", NULL
11951 };
11952
11953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11955 if (!SWIG_IsOK(res1)) {
11956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11957 }
11958 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11960 if (!SWIG_IsOK(res2)) {
11961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11962 }
11963 if (!argp2) {
11964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11965 }
11966 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11967 {
11968 arg3 = wxString_in_helper(obj2);
11969 if (arg3 == NULL) SWIG_fail;
11970 temp3 = true;
11971 }
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 {
11979 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11980 }
11981 {
11982 if (temp3)
11983 delete arg3;
11984 }
11985 return resultobj;
11986 fail:
11987 {
11988 if (temp3)
11989 delete arg3;
11990 }
11991 return NULL;
11992 }
11993
11994
11995 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11996 PyObject *resultobj = 0;
11997 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11998 wxString *arg2 = 0 ;
11999 int arg3 = (int) 0 ;
12000 wxString result;
12001 void *argp1 = 0 ;
12002 int res1 = 0 ;
12003 bool temp2 = false ;
12004 int val3 ;
12005 int ecode3 = 0 ;
12006 PyObject * obj0 = 0 ;
12007 PyObject * obj1 = 0 ;
12008 PyObject * obj2 = 0 ;
12009 char * kwnames[] = {
12010 (char *) "self",(char *) "spec",(char *) "flags", NULL
12011 };
12012
12013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12015 if (!SWIG_IsOK(res1)) {
12016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12017 }
12018 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12019 {
12020 arg2 = wxString_in_helper(obj1);
12021 if (arg2 == NULL) SWIG_fail;
12022 temp2 = true;
12023 }
12024 if (obj2) {
12025 ecode3 = SWIG_AsVal_int(obj2, &val3);
12026 if (!SWIG_IsOK(ecode3)) {
12027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12028 }
12029 arg3 = static_cast< int >(val3);
12030 }
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12034 wxPyEndAllowThreads(__tstate);
12035 if (PyErr_Occurred()) SWIG_fail;
12036 }
12037 {
12038 #if wxUSE_UNICODE
12039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12040 #else
12041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12042 #endif
12043 }
12044 {
12045 if (temp2)
12046 delete arg2;
12047 }
12048 return resultobj;
12049 fail:
12050 {
12051 if (temp2)
12052 delete arg2;
12053 }
12054 return NULL;
12055 }
12056
12057
12058 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12059 PyObject *resultobj = 0;
12060 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12061 wxString result;
12062 void *argp1 = 0 ;
12063 int res1 = 0 ;
12064 PyObject *swig_obj[1] ;
12065
12066 if (!args) SWIG_fail;
12067 swig_obj[0] = args;
12068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12069 if (!SWIG_IsOK(res1)) {
12070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12071 }
12072 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 result = (arg1)->FindNext();
12076 wxPyEndAllowThreads(__tstate);
12077 if (PyErr_Occurred()) SWIG_fail;
12078 }
12079 {
12080 #if wxUSE_UNICODE
12081 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12082 #else
12083 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12084 #endif
12085 }
12086 return resultobj;
12087 fail:
12088 return NULL;
12089 }
12090
12091
12092 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12093 PyObject *obj;
12094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12095 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12096 return SWIG_Py_Void();
12097 }
12098
12099 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12100 return SWIG_Python_InitShadowInstance(args);
12101 }
12102
12103 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12104 PyObject *resultobj = 0;
12105 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12106 wxString result;
12107 void *argp1 = 0 ;
12108 int res1 = 0 ;
12109 PyObject *swig_obj[1] ;
12110
12111 if (!args) SWIG_fail;
12112 swig_obj[0] = args;
12113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12114 if (!SWIG_IsOK(res1)) {
12115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12116 }
12117 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12118 {
12119 PyThreadState* __tstate = wxPyBeginAllowThreads();
12120 result = (arg1)->GetName();
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 {
12125 #if wxUSE_UNICODE
12126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12127 #else
12128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12129 #endif
12130 }
12131 return resultobj;
12132 fail:
12133 return NULL;
12134 }
12135
12136
12137 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12138 PyObject *resultobj = 0;
12139 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12140 wxString result;
12141 void *argp1 = 0 ;
12142 int res1 = 0 ;
12143 PyObject *swig_obj[1] ;
12144
12145 if (!args) SWIG_fail;
12146 swig_obj[0] = args;
12147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12148 if (!SWIG_IsOK(res1)) {
12149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12150 }
12151 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12152 {
12153 PyThreadState* __tstate = wxPyBeginAllowThreads();
12154 result = (arg1)->GetExtension();
12155 wxPyEndAllowThreads(__tstate);
12156 if (PyErr_Occurred()) SWIG_fail;
12157 }
12158 {
12159 #if wxUSE_UNICODE
12160 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12161 #else
12162 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12163 #endif
12164 }
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *resultobj = 0;
12173 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12174 long result;
12175 void *argp1 = 0 ;
12176 int res1 = 0 ;
12177 PyObject *swig_obj[1] ;
12178
12179 if (!args) SWIG_fail;
12180 swig_obj[0] = args;
12181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12182 if (!SWIG_IsOK(res1)) {
12183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12184 }
12185 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 result = (long)(arg1)->GetType();
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 resultobj = SWIG_From_long(static_cast< long >(result));
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12200 PyObject *resultobj = 0;
12201 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12202 wxString result;
12203 void *argp1 = 0 ;
12204 int res1 = 0 ;
12205 PyObject *swig_obj[1] ;
12206
12207 if (!args) SWIG_fail;
12208 swig_obj[0] = args;
12209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12210 if (!SWIG_IsOK(res1)) {
12211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12212 }
12213 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (arg1)->GetMimeType();
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 {
12221 #if wxUSE_UNICODE
12222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12223 #else
12224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12225 #endif
12226 }
12227 return resultobj;
12228 fail:
12229 return NULL;
12230 }
12231
12232
12233 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12234 PyObject *resultobj = 0;
12235 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12236 wxString *arg2 = 0 ;
12237 bool result;
12238 void *argp1 = 0 ;
12239 int res1 = 0 ;
12240 bool temp2 = false ;
12241 PyObject * obj0 = 0 ;
12242 PyObject * obj1 = 0 ;
12243 char * kwnames[] = {
12244 (char *) "self",(char *) "name", NULL
12245 };
12246
12247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12249 if (!SWIG_IsOK(res1)) {
12250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12251 }
12252 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12253 {
12254 arg2 = wxString_in_helper(obj1);
12255 if (arg2 == NULL) SWIG_fail;
12256 temp2 = true;
12257 }
12258 {
12259 PyThreadState* __tstate = wxPyBeginAllowThreads();
12260 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 {
12265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12266 }
12267 {
12268 if (temp2)
12269 delete arg2;
12270 }
12271 return resultobj;
12272 fail:
12273 {
12274 if (temp2)
12275 delete arg2;
12276 }
12277 return NULL;
12278 }
12279
12280
12281 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12282 PyObject *resultobj = 0;
12283 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12284 wxInputStream *arg2 = 0 ;
12285 bool result;
12286 void *argp1 = 0 ;
12287 int res1 = 0 ;
12288 wxPyInputStream *temp2 ;
12289 bool created2 ;
12290 PyObject * obj0 = 0 ;
12291 PyObject * obj1 = 0 ;
12292 char * kwnames[] = {
12293 (char *) "self",(char *) "stream", NULL
12294 };
12295
12296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12298 if (!SWIG_IsOK(res1)) {
12299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12300 }
12301 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12302 {
12303 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12304 arg2 = temp2->m_wxis;
12305 created2 = false;
12306 } else {
12307 PyErr_Clear(); // clear the failure of the wxPyConvert above
12308 arg2 = wxPyCBInputStream_create(obj1, false);
12309 if (arg2 == NULL) {
12310 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12311 SWIG_fail;
12312 }
12313 created2 = true;
12314 }
12315 }
12316 {
12317 PyThreadState* __tstate = wxPyBeginAllowThreads();
12318 result = (bool)(arg1)->CanRead(*arg2);
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12324 }
12325 {
12326 if (created2) delete arg2;
12327 }
12328 return resultobj;
12329 fail:
12330 {
12331 if (created2) delete arg2;
12332 }
12333 return NULL;
12334 }
12335
12336
12337 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj = 0;
12339 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12340 wxString *arg2 = 0 ;
12341 void *argp1 = 0 ;
12342 int res1 = 0 ;
12343 bool temp2 = false ;
12344 PyObject * obj0 = 0 ;
12345 PyObject * obj1 = 0 ;
12346 char * kwnames[] = {
12347 (char *) "self",(char *) "name", NULL
12348 };
12349
12350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12352 if (!SWIG_IsOK(res1)) {
12353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12354 }
12355 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12356 {
12357 arg2 = wxString_in_helper(obj1);
12358 if (arg2 == NULL) SWIG_fail;
12359 temp2 = true;
12360 }
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 (arg1)->SetName((wxString const &)*arg2);
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 resultobj = SWIG_Py_Void();
12368 {
12369 if (temp2)
12370 delete arg2;
12371 }
12372 return resultobj;
12373 fail:
12374 {
12375 if (temp2)
12376 delete arg2;
12377 }
12378 return NULL;
12379 }
12380
12381
12382 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12383 PyObject *resultobj = 0;
12384 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12385 wxString *arg2 = 0 ;
12386 void *argp1 = 0 ;
12387 int res1 = 0 ;
12388 bool temp2 = false ;
12389 PyObject * obj0 = 0 ;
12390 PyObject * obj1 = 0 ;
12391 char * kwnames[] = {
12392 (char *) "self",(char *) "extension", NULL
12393 };
12394
12395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12397 if (!SWIG_IsOK(res1)) {
12398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12399 }
12400 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12401 {
12402 arg2 = wxString_in_helper(obj1);
12403 if (arg2 == NULL) SWIG_fail;
12404 temp2 = true;
12405 }
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 (arg1)->SetExtension((wxString const &)*arg2);
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 resultobj = SWIG_Py_Void();
12413 {
12414 if (temp2)
12415 delete arg2;
12416 }
12417 return resultobj;
12418 fail:
12419 {
12420 if (temp2)
12421 delete arg2;
12422 }
12423 return NULL;
12424 }
12425
12426
12427 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12428 PyObject *resultobj = 0;
12429 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12430 long arg2 ;
12431 void *argp1 = 0 ;
12432 int res1 = 0 ;
12433 long val2 ;
12434 int ecode2 = 0 ;
12435 PyObject * obj0 = 0 ;
12436 PyObject * obj1 = 0 ;
12437 char * kwnames[] = {
12438 (char *) "self",(char *) "type", NULL
12439 };
12440
12441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12443 if (!SWIG_IsOK(res1)) {
12444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12445 }
12446 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12447 ecode2 = SWIG_AsVal_long(obj1, &val2);
12448 if (!SWIG_IsOK(ecode2)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12450 }
12451 arg2 = static_cast< long >(val2);
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 (arg1)->SetType(arg2);
12455 wxPyEndAllowThreads(__tstate);
12456 if (PyErr_Occurred()) SWIG_fail;
12457 }
12458 resultobj = SWIG_Py_Void();
12459 return resultobj;
12460 fail:
12461 return NULL;
12462 }
12463
12464
12465 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12466 PyObject *resultobj = 0;
12467 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12468 wxString *arg2 = 0 ;
12469 void *argp1 = 0 ;
12470 int res1 = 0 ;
12471 bool temp2 = false ;
12472 PyObject * obj0 = 0 ;
12473 PyObject * obj1 = 0 ;
12474 char * kwnames[] = {
12475 (char *) "self",(char *) "mimetype", NULL
12476 };
12477
12478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12480 if (!SWIG_IsOK(res1)) {
12481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12482 }
12483 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12484 {
12485 arg2 = wxString_in_helper(obj1);
12486 if (arg2 == NULL) SWIG_fail;
12487 temp2 = true;
12488 }
12489 {
12490 PyThreadState* __tstate = wxPyBeginAllowThreads();
12491 (arg1)->SetMimeType((wxString const &)*arg2);
12492 wxPyEndAllowThreads(__tstate);
12493 if (PyErr_Occurred()) SWIG_fail;
12494 }
12495 resultobj = SWIG_Py_Void();
12496 {
12497 if (temp2)
12498 delete arg2;
12499 }
12500 return resultobj;
12501 fail:
12502 {
12503 if (temp2)
12504 delete arg2;
12505 }
12506 return NULL;
12507 }
12508
12509
12510 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12511 PyObject *obj;
12512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12513 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12514 return SWIG_Py_Void();
12515 }
12516
12517 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12518 PyObject *resultobj = 0;
12519 wxPyImageHandler *result = 0 ;
12520
12521 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12522 {
12523 PyThreadState* __tstate = wxPyBeginAllowThreads();
12524 result = (wxPyImageHandler *)new wxPyImageHandler();
12525 wxPyEndAllowThreads(__tstate);
12526 if (PyErr_Occurred()) SWIG_fail;
12527 }
12528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj = 0;
12537 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12538 PyObject *arg2 = (PyObject *) 0 ;
12539 void *argp1 = 0 ;
12540 int res1 = 0 ;
12541 PyObject * obj0 = 0 ;
12542 PyObject * obj1 = 0 ;
12543 char * kwnames[] = {
12544 (char *) "self",(char *) "self", NULL
12545 };
12546
12547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12549 if (!SWIG_IsOK(res1)) {
12550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12551 }
12552 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12553 arg2 = obj1;
12554 {
12555 PyThreadState* __tstate = wxPyBeginAllowThreads();
12556 (arg1)->_SetSelf(arg2);
12557 wxPyEndAllowThreads(__tstate);
12558 if (PyErr_Occurred()) SWIG_fail;
12559 }
12560 resultobj = SWIG_Py_Void();
12561 return resultobj;
12562 fail:
12563 return NULL;
12564 }
12565
12566
12567 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12568 PyObject *obj;
12569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12570 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12571 return SWIG_Py_Void();
12572 }
12573
12574 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12575 return SWIG_Python_InitShadowInstance(args);
12576 }
12577
12578 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12579 PyObject *resultobj = 0;
12580 wxImageHistogram *result = 0 ;
12581
12582 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12583 {
12584 PyThreadState* __tstate = wxPyBeginAllowThreads();
12585 result = (wxImageHistogram *)new wxImageHistogram();
12586 wxPyEndAllowThreads(__tstate);
12587 if (PyErr_Occurred()) SWIG_fail;
12588 }
12589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12597 PyObject *resultobj = 0;
12598 byte arg1 ;
12599 byte arg2 ;
12600 byte arg3 ;
12601 unsigned long result;
12602 unsigned char val1 ;
12603 int ecode1 = 0 ;
12604 unsigned char val2 ;
12605 int ecode2 = 0 ;
12606 unsigned char val3 ;
12607 int ecode3 = 0 ;
12608 PyObject * obj0 = 0 ;
12609 PyObject * obj1 = 0 ;
12610 PyObject * obj2 = 0 ;
12611 char * kwnames[] = {
12612 (char *) "r",(char *) "g",(char *) "b", NULL
12613 };
12614
12615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12616 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12617 if (!SWIG_IsOK(ecode1)) {
12618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12619 }
12620 arg1 = static_cast< byte >(val1);
12621 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12622 if (!SWIG_IsOK(ecode2)) {
12623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12624 }
12625 arg2 = static_cast< byte >(val2);
12626 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12627 if (!SWIG_IsOK(ecode3)) {
12628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12629 }
12630 arg3 = static_cast< byte >(val3);
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12634 wxPyEndAllowThreads(__tstate);
12635 if (PyErr_Occurred()) SWIG_fail;
12636 }
12637 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12638 return resultobj;
12639 fail:
12640 return NULL;
12641 }
12642
12643
12644 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12645 PyObject *resultobj = 0;
12646 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12647 byte *arg2 = (byte *) 0 ;
12648 byte *arg3 = (byte *) 0 ;
12649 byte *arg4 = (byte *) 0 ;
12650 byte arg5 = (byte) 1 ;
12651 byte arg6 = (byte) 0 ;
12652 byte arg7 = (byte) 0 ;
12653 bool result;
12654 void *argp1 = 0 ;
12655 int res1 = 0 ;
12656 byte temp2 ;
12657 int res2 = SWIG_TMPOBJ ;
12658 byte temp3 ;
12659 int res3 = SWIG_TMPOBJ ;
12660 byte temp4 ;
12661 int res4 = SWIG_TMPOBJ ;
12662 unsigned char val5 ;
12663 int ecode5 = 0 ;
12664 unsigned char val6 ;
12665 int ecode6 = 0 ;
12666 unsigned char val7 ;
12667 int ecode7 = 0 ;
12668 PyObject * obj0 = 0 ;
12669 PyObject * obj1 = 0 ;
12670 PyObject * obj2 = 0 ;
12671 PyObject * obj3 = 0 ;
12672 char * kwnames[] = {
12673 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12674 };
12675
12676 arg2 = &temp2;
12677 arg3 = &temp3;
12678 arg4 = &temp4;
12679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12681 if (!SWIG_IsOK(res1)) {
12682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12683 }
12684 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12685 if (obj1) {
12686 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12687 if (!SWIG_IsOK(ecode5)) {
12688 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12689 }
12690 arg5 = static_cast< byte >(val5);
12691 }
12692 if (obj2) {
12693 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12694 if (!SWIG_IsOK(ecode6)) {
12695 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12696 }
12697 arg6 = static_cast< byte >(val6);
12698 }
12699 if (obj3) {
12700 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12701 if (!SWIG_IsOK(ecode7)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12703 }
12704 arg7 = static_cast< byte >(val7);
12705 }
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 {
12713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12714 }
12715 if (SWIG_IsTmpObj(res2)) {
12716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12717 } else {
12718 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12720 }
12721 if (SWIG_IsTmpObj(res3)) {
12722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12723 } else {
12724 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12726 }
12727 if (SWIG_IsTmpObj(res4)) {
12728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12729 } else {
12730 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12732 }
12733 return resultobj;
12734 fail:
12735 return NULL;
12736 }
12737
12738
12739 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12740 PyObject *resultobj = 0;
12741 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12742 unsigned long arg2 ;
12743 unsigned long result;
12744 void *argp1 = 0 ;
12745 int res1 = 0 ;
12746 unsigned long val2 ;
12747 int ecode2 = 0 ;
12748 PyObject * obj0 = 0 ;
12749 PyObject * obj1 = 0 ;
12750 char * kwnames[] = {
12751 (char *) "self",(char *) "key", NULL
12752 };
12753
12754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12756 if (!SWIG_IsOK(res1)) {
12757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12758 }
12759 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12760 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12761 if (!SWIG_IsOK(ecode2)) {
12762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12763 }
12764 arg2 = static_cast< unsigned long >(val2);
12765 {
12766 PyThreadState* __tstate = wxPyBeginAllowThreads();
12767 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12779 PyObject *resultobj = 0;
12780 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12781 byte arg2 ;
12782 byte arg3 ;
12783 byte arg4 ;
12784 unsigned long result;
12785 void *argp1 = 0 ;
12786 int res1 = 0 ;
12787 unsigned char val2 ;
12788 int ecode2 = 0 ;
12789 unsigned char val3 ;
12790 int ecode3 = 0 ;
12791 unsigned char val4 ;
12792 int ecode4 = 0 ;
12793 PyObject * obj0 = 0 ;
12794 PyObject * obj1 = 0 ;
12795 PyObject * obj2 = 0 ;
12796 PyObject * obj3 = 0 ;
12797 char * kwnames[] = {
12798 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12799 };
12800
12801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12803 if (!SWIG_IsOK(res1)) {
12804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12805 }
12806 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12807 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12808 if (!SWIG_IsOK(ecode2)) {
12809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12810 }
12811 arg2 = static_cast< byte >(val2);
12812 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12813 if (!SWIG_IsOK(ecode3)) {
12814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12815 }
12816 arg3 = static_cast< byte >(val3);
12817 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12818 if (!SWIG_IsOK(ecode4)) {
12819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12820 }
12821 arg4 = static_cast< byte >(val4);
12822 {
12823 PyThreadState* __tstate = wxPyBeginAllowThreads();
12824 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12825 wxPyEndAllowThreads(__tstate);
12826 if (PyErr_Occurred()) SWIG_fail;
12827 }
12828 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12829 return resultobj;
12830 fail:
12831 return NULL;
12832 }
12833
12834
12835 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12836 PyObject *resultobj = 0;
12837 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12838 wxColour *arg2 = 0 ;
12839 unsigned long result;
12840 void *argp1 = 0 ;
12841 int res1 = 0 ;
12842 wxColour temp2 ;
12843 PyObject * obj0 = 0 ;
12844 PyObject * obj1 = 0 ;
12845 char * kwnames[] = {
12846 (char *) "self",(char *) "colour", NULL
12847 };
12848
12849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12851 if (!SWIG_IsOK(res1)) {
12852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12853 }
12854 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12855 {
12856 arg2 = &temp2;
12857 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12858 }
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12866 return resultobj;
12867 fail:
12868 return NULL;
12869 }
12870
12871
12872 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12873 PyObject *obj;
12874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12875 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12876 return SWIG_Py_Void();
12877 }
12878
12879 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12880 return SWIG_Python_InitShadowInstance(args);
12881 }
12882
12883 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12884 PyObject *resultobj = 0;
12885 byte arg1 = (byte) 0 ;
12886 byte arg2 = (byte) 0 ;
12887 byte arg3 = (byte) 0 ;
12888 wxImage_RGBValue *result = 0 ;
12889 unsigned char val1 ;
12890 int ecode1 = 0 ;
12891 unsigned char val2 ;
12892 int ecode2 = 0 ;
12893 unsigned char val3 ;
12894 int ecode3 = 0 ;
12895 PyObject * obj0 = 0 ;
12896 PyObject * obj1 = 0 ;
12897 PyObject * obj2 = 0 ;
12898 char * kwnames[] = {
12899 (char *) "r",(char *) "g",(char *) "b", NULL
12900 };
12901
12902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12903 if (obj0) {
12904 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12905 if (!SWIG_IsOK(ecode1)) {
12906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12907 }
12908 arg1 = static_cast< byte >(val1);
12909 }
12910 if (obj1) {
12911 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12912 if (!SWIG_IsOK(ecode2)) {
12913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12914 }
12915 arg2 = static_cast< byte >(val2);
12916 }
12917 if (obj2) {
12918 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12919 if (!SWIG_IsOK(ecode3)) {
12920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12921 }
12922 arg3 = static_cast< byte >(val3);
12923 }
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *resultobj = 0;
12939 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12940 byte arg2 ;
12941 void *argp1 = 0 ;
12942 int res1 = 0 ;
12943 unsigned char val2 ;
12944 int ecode2 = 0 ;
12945 PyObject *swig_obj[2] ;
12946
12947 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12951 }
12952 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12953 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12954 if (!SWIG_IsOK(ecode2)) {
12955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12956 }
12957 arg2 = static_cast< byte >(val2);
12958 if (arg1) (arg1)->red = arg2;
12959
12960 resultobj = SWIG_Py_Void();
12961 return resultobj;
12962 fail:
12963 return NULL;
12964 }
12965
12966
12967 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12968 PyObject *resultobj = 0;
12969 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12970 byte result;
12971 void *argp1 = 0 ;
12972 int res1 = 0 ;
12973 PyObject *swig_obj[1] ;
12974
12975 if (!args) SWIG_fail;
12976 swig_obj[0] = args;
12977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12978 if (!SWIG_IsOK(res1)) {
12979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12980 }
12981 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12982 result = (byte) ((arg1)->red);
12983 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12991 PyObject *resultobj = 0;
12992 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12993 byte arg2 ;
12994 void *argp1 = 0 ;
12995 int res1 = 0 ;
12996 unsigned char val2 ;
12997 int ecode2 = 0 ;
12998 PyObject *swig_obj[2] ;
12999
13000 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
13001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13002 if (!SWIG_IsOK(res1)) {
13003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13004 }
13005 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13006 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13007 if (!SWIG_IsOK(ecode2)) {
13008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
13009 }
13010 arg2 = static_cast< byte >(val2);
13011 if (arg1) (arg1)->green = arg2;
13012
13013 resultobj = SWIG_Py_Void();
13014 return resultobj;
13015 fail:
13016 return NULL;
13017 }
13018
13019
13020 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13021 PyObject *resultobj = 0;
13022 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13023 byte result;
13024 void *argp1 = 0 ;
13025 int res1 = 0 ;
13026 PyObject *swig_obj[1] ;
13027
13028 if (!args) SWIG_fail;
13029 swig_obj[0] = args;
13030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13031 if (!SWIG_IsOK(res1)) {
13032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13033 }
13034 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13035 result = (byte) ((arg1)->green);
13036 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13037 return resultobj;
13038 fail:
13039 return NULL;
13040 }
13041
13042
13043 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13044 PyObject *resultobj = 0;
13045 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13046 byte arg2 ;
13047 void *argp1 = 0 ;
13048 int res1 = 0 ;
13049 unsigned char val2 ;
13050 int ecode2 = 0 ;
13051 PyObject *swig_obj[2] ;
13052
13053 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13055 if (!SWIG_IsOK(res1)) {
13056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13057 }
13058 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13059 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13060 if (!SWIG_IsOK(ecode2)) {
13061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13062 }
13063 arg2 = static_cast< byte >(val2);
13064 if (arg1) (arg1)->blue = arg2;
13065
13066 resultobj = SWIG_Py_Void();
13067 return resultobj;
13068 fail:
13069 return NULL;
13070 }
13071
13072
13073 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13074 PyObject *resultobj = 0;
13075 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13076 byte result;
13077 void *argp1 = 0 ;
13078 int res1 = 0 ;
13079 PyObject *swig_obj[1] ;
13080
13081 if (!args) SWIG_fail;
13082 swig_obj[0] = args;
13083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13084 if (!SWIG_IsOK(res1)) {
13085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13086 }
13087 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13088 result = (byte) ((arg1)->blue);
13089 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13090 return resultobj;
13091 fail:
13092 return NULL;
13093 }
13094
13095
13096 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13097 PyObject *obj;
13098 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13099 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13100 return SWIG_Py_Void();
13101 }
13102
13103 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13104 return SWIG_Python_InitShadowInstance(args);
13105 }
13106
13107 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13108 PyObject *resultobj = 0;
13109 double arg1 = (double) 0.0 ;
13110 double arg2 = (double) 0.0 ;
13111 double arg3 = (double) 0.0 ;
13112 wxImage_HSVValue *result = 0 ;
13113 double val1 ;
13114 int ecode1 = 0 ;
13115 double val2 ;
13116 int ecode2 = 0 ;
13117 double val3 ;
13118 int ecode3 = 0 ;
13119 PyObject * obj0 = 0 ;
13120 PyObject * obj1 = 0 ;
13121 PyObject * obj2 = 0 ;
13122 char * kwnames[] = {
13123 (char *) "h",(char *) "s",(char *) "v", NULL
13124 };
13125
13126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13127 if (obj0) {
13128 ecode1 = SWIG_AsVal_double(obj0, &val1);
13129 if (!SWIG_IsOK(ecode1)) {
13130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13131 }
13132 arg1 = static_cast< double >(val1);
13133 }
13134 if (obj1) {
13135 ecode2 = SWIG_AsVal_double(obj1, &val2);
13136 if (!SWIG_IsOK(ecode2)) {
13137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13138 }
13139 arg2 = static_cast< double >(val2);
13140 }
13141 if (obj2) {
13142 ecode3 = SWIG_AsVal_double(obj2, &val3);
13143 if (!SWIG_IsOK(ecode3)) {
13144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13145 }
13146 arg3 = static_cast< double >(val3);
13147 }
13148 {
13149 PyThreadState* __tstate = wxPyBeginAllowThreads();
13150 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13151 wxPyEndAllowThreads(__tstate);
13152 if (PyErr_Occurred()) SWIG_fail;
13153 }
13154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13155 return resultobj;
13156 fail:
13157 return NULL;
13158 }
13159
13160
13161 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13162 PyObject *resultobj = 0;
13163 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13164 double arg2 ;
13165 void *argp1 = 0 ;
13166 int res1 = 0 ;
13167 double val2 ;
13168 int ecode2 = 0 ;
13169 PyObject *swig_obj[2] ;
13170
13171 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13173 if (!SWIG_IsOK(res1)) {
13174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13175 }
13176 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13177 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13178 if (!SWIG_IsOK(ecode2)) {
13179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13180 }
13181 arg2 = static_cast< double >(val2);
13182 if (arg1) (arg1)->hue = arg2;
13183
13184 resultobj = SWIG_Py_Void();
13185 return resultobj;
13186 fail:
13187 return NULL;
13188 }
13189
13190
13191 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13192 PyObject *resultobj = 0;
13193 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13194 double result;
13195 void *argp1 = 0 ;
13196 int res1 = 0 ;
13197 PyObject *swig_obj[1] ;
13198
13199 if (!args) SWIG_fail;
13200 swig_obj[0] = args;
13201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13202 if (!SWIG_IsOK(res1)) {
13203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13204 }
13205 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13206 result = (double) ((arg1)->hue);
13207 resultobj = SWIG_From_double(static_cast< double >(result));
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13215 PyObject *resultobj = 0;
13216 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13217 double arg2 ;
13218 void *argp1 = 0 ;
13219 int res1 = 0 ;
13220 double val2 ;
13221 int ecode2 = 0 ;
13222 PyObject *swig_obj[2] ;
13223
13224 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13226 if (!SWIG_IsOK(res1)) {
13227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13228 }
13229 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13230 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13231 if (!SWIG_IsOK(ecode2)) {
13232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13233 }
13234 arg2 = static_cast< double >(val2);
13235 if (arg1) (arg1)->saturation = arg2;
13236
13237 resultobj = SWIG_Py_Void();
13238 return resultobj;
13239 fail:
13240 return NULL;
13241 }
13242
13243
13244 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13245 PyObject *resultobj = 0;
13246 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13247 double result;
13248 void *argp1 = 0 ;
13249 int res1 = 0 ;
13250 PyObject *swig_obj[1] ;
13251
13252 if (!args) SWIG_fail;
13253 swig_obj[0] = args;
13254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13255 if (!SWIG_IsOK(res1)) {
13256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13257 }
13258 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13259 result = (double) ((arg1)->saturation);
13260 resultobj = SWIG_From_double(static_cast< double >(result));
13261 return resultobj;
13262 fail:
13263 return NULL;
13264 }
13265
13266
13267 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13268 PyObject *resultobj = 0;
13269 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13270 double arg2 ;
13271 void *argp1 = 0 ;
13272 int res1 = 0 ;
13273 double val2 ;
13274 int ecode2 = 0 ;
13275 PyObject *swig_obj[2] ;
13276
13277 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13279 if (!SWIG_IsOK(res1)) {
13280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13281 }
13282 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13283 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13284 if (!SWIG_IsOK(ecode2)) {
13285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13286 }
13287 arg2 = static_cast< double >(val2);
13288 if (arg1) (arg1)->value = arg2;
13289
13290 resultobj = SWIG_Py_Void();
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13298 PyObject *resultobj = 0;
13299 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13300 double result;
13301 void *argp1 = 0 ;
13302 int res1 = 0 ;
13303 PyObject *swig_obj[1] ;
13304
13305 if (!args) SWIG_fail;
13306 swig_obj[0] = args;
13307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13308 if (!SWIG_IsOK(res1)) {
13309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13310 }
13311 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13312 result = (double) ((arg1)->value);
13313 resultobj = SWIG_From_double(static_cast< double >(result));
13314 return resultobj;
13315 fail:
13316 return NULL;
13317 }
13318
13319
13320 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13321 PyObject *obj;
13322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13323 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13324 return SWIG_Py_Void();
13325 }
13326
13327 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13328 return SWIG_Python_InitShadowInstance(args);
13329 }
13330
13331 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13332 PyObject *resultobj = 0;
13333 wxString *arg1 = 0 ;
13334 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13335 int arg3 = (int) -1 ;
13336 wxImage *result = 0 ;
13337 bool temp1 = false ;
13338 long val2 ;
13339 int ecode2 = 0 ;
13340 int val3 ;
13341 int ecode3 = 0 ;
13342 PyObject * obj0 = 0 ;
13343 PyObject * obj1 = 0 ;
13344 PyObject * obj2 = 0 ;
13345 char * kwnames[] = {
13346 (char *) "name",(char *) "type",(char *) "index", NULL
13347 };
13348
13349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13350 {
13351 arg1 = wxString_in_helper(obj0);
13352 if (arg1 == NULL) SWIG_fail;
13353 temp1 = true;
13354 }
13355 if (obj1) {
13356 ecode2 = SWIG_AsVal_long(obj1, &val2);
13357 if (!SWIG_IsOK(ecode2)) {
13358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13359 }
13360 arg2 = static_cast< long >(val2);
13361 }
13362 if (obj2) {
13363 ecode3 = SWIG_AsVal_int(obj2, &val3);
13364 if (!SWIG_IsOK(ecode3)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13366 }
13367 arg3 = static_cast< int >(val3);
13368 }
13369 {
13370 PyThreadState* __tstate = wxPyBeginAllowThreads();
13371 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13372 wxPyEndAllowThreads(__tstate);
13373 if (PyErr_Occurred()) SWIG_fail;
13374 }
13375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13376 {
13377 if (temp1)
13378 delete arg1;
13379 }
13380 return resultobj;
13381 fail:
13382 {
13383 if (temp1)
13384 delete arg1;
13385 }
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13391 PyObject *resultobj = 0;
13392 wxImage *arg1 = (wxImage *) 0 ;
13393 void *argp1 = 0 ;
13394 int res1 = 0 ;
13395 PyObject *swig_obj[1] ;
13396
13397 if (!args) SWIG_fail;
13398 swig_obj[0] = args;
13399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13400 if (!SWIG_IsOK(res1)) {
13401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13402 }
13403 arg1 = reinterpret_cast< wxImage * >(argp1);
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 delete arg1;
13407
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 resultobj = SWIG_Py_Void();
13412 return resultobj;
13413 fail:
13414 return NULL;
13415 }
13416
13417
13418 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13419 PyObject *resultobj = 0;
13420 wxString *arg1 = 0 ;
13421 wxString *arg2 = 0 ;
13422 int arg3 = (int) -1 ;
13423 wxImage *result = 0 ;
13424 bool temp1 = false ;
13425 bool temp2 = false ;
13426 int val3 ;
13427 int ecode3 = 0 ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 PyObject * obj2 = 0 ;
13431 char * kwnames[] = {
13432 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13433 };
13434
13435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13436 {
13437 arg1 = wxString_in_helper(obj0);
13438 if (arg1 == NULL) SWIG_fail;
13439 temp1 = true;
13440 }
13441 {
13442 arg2 = wxString_in_helper(obj1);
13443 if (arg2 == NULL) SWIG_fail;
13444 temp2 = true;
13445 }
13446 if (obj2) {
13447 ecode3 = SWIG_AsVal_int(obj2, &val3);
13448 if (!SWIG_IsOK(ecode3)) {
13449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13450 }
13451 arg3 = static_cast< int >(val3);
13452 }
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13460 {
13461 if (temp1)
13462 delete arg1;
13463 }
13464 {
13465 if (temp2)
13466 delete arg2;
13467 }
13468 return resultobj;
13469 fail:
13470 {
13471 if (temp1)
13472 delete arg1;
13473 }
13474 {
13475 if (temp2)
13476 delete arg2;
13477 }
13478 return NULL;
13479 }
13480
13481
13482 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13483 PyObject *resultobj = 0;
13484 wxInputStream *arg1 = 0 ;
13485 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13486 int arg3 = (int) -1 ;
13487 wxImage *result = 0 ;
13488 wxPyInputStream *temp1 ;
13489 bool created1 ;
13490 long val2 ;
13491 int ecode2 = 0 ;
13492 int val3 ;
13493 int ecode3 = 0 ;
13494 PyObject * obj0 = 0 ;
13495 PyObject * obj1 = 0 ;
13496 PyObject * obj2 = 0 ;
13497 char * kwnames[] = {
13498 (char *) "stream",(char *) "type",(char *) "index", NULL
13499 };
13500
13501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13502 {
13503 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13504 arg1 = temp1->m_wxis;
13505 created1 = false;
13506 } else {
13507 PyErr_Clear(); // clear the failure of the wxPyConvert above
13508 arg1 = wxPyCBInputStream_create(obj0, false);
13509 if (arg1 == NULL) {
13510 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13511 SWIG_fail;
13512 }
13513 created1 = true;
13514 }
13515 }
13516 if (obj1) {
13517 ecode2 = SWIG_AsVal_long(obj1, &val2);
13518 if (!SWIG_IsOK(ecode2)) {
13519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13520 }
13521 arg2 = static_cast< long >(val2);
13522 }
13523 if (obj2) {
13524 ecode3 = SWIG_AsVal_int(obj2, &val3);
13525 if (!SWIG_IsOK(ecode3)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13527 }
13528 arg3 = static_cast< int >(val3);
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13537 {
13538 if (created1) delete arg1;
13539 }
13540 return resultobj;
13541 fail:
13542 {
13543 if (created1) delete arg1;
13544 }
13545 return NULL;
13546 }
13547
13548
13549 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13550 PyObject *resultobj = 0;
13551 wxInputStream *arg1 = 0 ;
13552 wxString *arg2 = 0 ;
13553 int arg3 = (int) -1 ;
13554 wxImage *result = 0 ;
13555 wxPyInputStream *temp1 ;
13556 bool created1 ;
13557 bool temp2 = false ;
13558 int val3 ;
13559 int ecode3 = 0 ;
13560 PyObject * obj0 = 0 ;
13561 PyObject * obj1 = 0 ;
13562 PyObject * obj2 = 0 ;
13563 char * kwnames[] = {
13564 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13565 };
13566
13567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13568 {
13569 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13570 arg1 = temp1->m_wxis;
13571 created1 = false;
13572 } else {
13573 PyErr_Clear(); // clear the failure of the wxPyConvert above
13574 arg1 = wxPyCBInputStream_create(obj0, false);
13575 if (arg1 == NULL) {
13576 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13577 SWIG_fail;
13578 }
13579 created1 = true;
13580 }
13581 }
13582 {
13583 arg2 = wxString_in_helper(obj1);
13584 if (arg2 == NULL) SWIG_fail;
13585 temp2 = true;
13586 }
13587 if (obj2) {
13588 ecode3 = SWIG_AsVal_int(obj2, &val3);
13589 if (!SWIG_IsOK(ecode3)) {
13590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13591 }
13592 arg3 = static_cast< int >(val3);
13593 }
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13597 wxPyEndAllowThreads(__tstate);
13598 if (PyErr_Occurred()) SWIG_fail;
13599 }
13600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13601 {
13602 if (created1) delete arg1;
13603 }
13604 {
13605 if (temp2)
13606 delete arg2;
13607 }
13608 return resultobj;
13609 fail:
13610 {
13611 if (created1) delete arg1;
13612 }
13613 {
13614 if (temp2)
13615 delete arg2;
13616 }
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 int arg1 = (int) 0 ;
13624 int arg2 = (int) 0 ;
13625 bool arg3 = (bool) true ;
13626 wxImage *result = 0 ;
13627 int val1 ;
13628 int ecode1 = 0 ;
13629 int val2 ;
13630 int ecode2 = 0 ;
13631 bool val3 ;
13632 int ecode3 = 0 ;
13633 PyObject * obj0 = 0 ;
13634 PyObject * obj1 = 0 ;
13635 PyObject * obj2 = 0 ;
13636 char * kwnames[] = {
13637 (char *) "width",(char *) "height",(char *) "clear", NULL
13638 };
13639
13640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13641 if (obj0) {
13642 ecode1 = SWIG_AsVal_int(obj0, &val1);
13643 if (!SWIG_IsOK(ecode1)) {
13644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13645 }
13646 arg1 = static_cast< int >(val1);
13647 }
13648 if (obj1) {
13649 ecode2 = SWIG_AsVal_int(obj1, &val2);
13650 if (!SWIG_IsOK(ecode2)) {
13651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13652 }
13653 arg2 = static_cast< int >(val2);
13654 }
13655 if (obj2) {
13656 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13657 if (!SWIG_IsOK(ecode3)) {
13658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13659 }
13660 arg3 = static_cast< bool >(val3);
13661 }
13662 {
13663 PyThreadState* __tstate = wxPyBeginAllowThreads();
13664 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13665 wxPyEndAllowThreads(__tstate);
13666 if (PyErr_Occurred()) SWIG_fail;
13667 }
13668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13669 return resultobj;
13670 fail:
13671 return NULL;
13672 }
13673
13674
13675 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13676 PyObject *resultobj = 0;
13677 wxBitmap *arg1 = 0 ;
13678 wxImage *result = 0 ;
13679 void *argp1 = 0 ;
13680 int res1 = 0 ;
13681 PyObject * obj0 = 0 ;
13682 char * kwnames[] = {
13683 (char *) "bitmap", NULL
13684 };
13685
13686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13687 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13688 if (!SWIG_IsOK(res1)) {
13689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13690 }
13691 if (!argp1) {
13692 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13693 }
13694 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13695 {
13696 if (!wxPyCheckForApp()) SWIG_fail;
13697 PyThreadState* __tstate = wxPyBeginAllowThreads();
13698 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13699 wxPyEndAllowThreads(__tstate);
13700 if (PyErr_Occurred()) SWIG_fail;
13701 }
13702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13703 return resultobj;
13704 fail:
13705 return NULL;
13706 }
13707
13708
13709 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13710 PyObject *resultobj = 0;
13711 int arg1 ;
13712 int arg2 ;
13713 buffer arg3 ;
13714 int arg4 ;
13715 wxImage *result = 0 ;
13716 int val1 ;
13717 int ecode1 = 0 ;
13718 int val2 ;
13719 int ecode2 = 0 ;
13720 Py_ssize_t temp3 ;
13721 PyObject * obj0 = 0 ;
13722 PyObject * obj1 = 0 ;
13723 PyObject * obj2 = 0 ;
13724 char * kwnames[] = {
13725 (char *) "width",(char *) "height",(char *) "data", NULL
13726 };
13727
13728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13729 ecode1 = SWIG_AsVal_int(obj0, &val1);
13730 if (!SWIG_IsOK(ecode1)) {
13731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13732 }
13733 arg1 = static_cast< int >(val1);
13734 ecode2 = SWIG_AsVal_int(obj1, &val2);
13735 if (!SWIG_IsOK(ecode2)) {
13736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13737 }
13738 arg2 = static_cast< int >(val2);
13739 {
13740 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13741 arg4 = (int)temp3;
13742 }
13743 {
13744 PyThreadState* __tstate = wxPyBeginAllowThreads();
13745 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13746 wxPyEndAllowThreads(__tstate);
13747 if (PyErr_Occurred()) SWIG_fail;
13748 }
13749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13750 return resultobj;
13751 fail:
13752 return NULL;
13753 }
13754
13755
13756 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj = 0;
13758 int arg1 ;
13759 int arg2 ;
13760 buffer arg3 ;
13761 int arg4 ;
13762 buffer arg5 ;
13763 int arg6 ;
13764 wxImage *result = 0 ;
13765 int val1 ;
13766 int ecode1 = 0 ;
13767 int val2 ;
13768 int ecode2 = 0 ;
13769 Py_ssize_t temp3 ;
13770 Py_ssize_t temp5 ;
13771 PyObject * obj0 = 0 ;
13772 PyObject * obj1 = 0 ;
13773 PyObject * obj2 = 0 ;
13774 PyObject * obj3 = 0 ;
13775 char * kwnames[] = {
13776 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13777 };
13778
13779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13780 ecode1 = SWIG_AsVal_int(obj0, &val1);
13781 if (!SWIG_IsOK(ecode1)) {
13782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13783 }
13784 arg1 = static_cast< int >(val1);
13785 ecode2 = SWIG_AsVal_int(obj1, &val2);
13786 if (!SWIG_IsOK(ecode2)) {
13787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13788 }
13789 arg2 = static_cast< int >(val2);
13790 {
13791 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13792 arg4 = (int)temp3;
13793 }
13794 {
13795 if (obj3 != Py_None) {
13796 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13797 arg6 = (int)temp5;
13798 }
13799 }
13800 {
13801 PyThreadState* __tstate = wxPyBeginAllowThreads();
13802 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13803 wxPyEndAllowThreads(__tstate);
13804 if (PyErr_Occurred()) SWIG_fail;
13805 }
13806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13807 return resultobj;
13808 fail:
13809 return NULL;
13810 }
13811
13812
13813 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13814 PyObject *resultobj = 0;
13815 wxImage *arg1 = (wxImage *) 0 ;
13816 int arg2 ;
13817 int arg3 ;
13818 bool arg4 = (bool) true ;
13819 void *argp1 = 0 ;
13820 int res1 = 0 ;
13821 int val2 ;
13822 int ecode2 = 0 ;
13823 int val3 ;
13824 int ecode3 = 0 ;
13825 bool val4 ;
13826 int ecode4 = 0 ;
13827 PyObject * obj0 = 0 ;
13828 PyObject * obj1 = 0 ;
13829 PyObject * obj2 = 0 ;
13830 PyObject * obj3 = 0 ;
13831 char * kwnames[] = {
13832 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13833 };
13834
13835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13837 if (!SWIG_IsOK(res1)) {
13838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13839 }
13840 arg1 = reinterpret_cast< wxImage * >(argp1);
13841 ecode2 = SWIG_AsVal_int(obj1, &val2);
13842 if (!SWIG_IsOK(ecode2)) {
13843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13844 }
13845 arg2 = static_cast< int >(val2);
13846 ecode3 = SWIG_AsVal_int(obj2, &val3);
13847 if (!SWIG_IsOK(ecode3)) {
13848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13849 }
13850 arg3 = static_cast< int >(val3);
13851 if (obj3) {
13852 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13853 if (!SWIG_IsOK(ecode4)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13855 }
13856 arg4 = static_cast< bool >(val4);
13857 }
13858 {
13859 PyThreadState* __tstate = wxPyBeginAllowThreads();
13860 (arg1)->Create(arg2,arg3,arg4);
13861 wxPyEndAllowThreads(__tstate);
13862 if (PyErr_Occurred()) SWIG_fail;
13863 }
13864 resultobj = SWIG_Py_Void();
13865 return resultobj;
13866 fail:
13867 return NULL;
13868 }
13869
13870
13871 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13872 PyObject *resultobj = 0;
13873 wxImage *arg1 = (wxImage *) 0 ;
13874 void *argp1 = 0 ;
13875 int res1 = 0 ;
13876 PyObject *swig_obj[1] ;
13877
13878 if (!args) SWIG_fail;
13879 swig_obj[0] = args;
13880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13881 if (!SWIG_IsOK(res1)) {
13882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13883 }
13884 arg1 = reinterpret_cast< wxImage * >(argp1);
13885 {
13886 PyThreadState* __tstate = wxPyBeginAllowThreads();
13887 (arg1)->Destroy();
13888 wxPyEndAllowThreads(__tstate);
13889 if (PyErr_Occurred()) SWIG_fail;
13890 }
13891 resultobj = SWIG_Py_Void();
13892 return resultobj;
13893 fail:
13894 return NULL;
13895 }
13896
13897
13898 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13899 PyObject *resultobj = 0;
13900 wxImage *arg1 = (wxImage *) 0 ;
13901 int arg2 ;
13902 int arg3 ;
13903 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13904 SwigValueWrapper<wxImage > result;
13905 void *argp1 = 0 ;
13906 int res1 = 0 ;
13907 int val2 ;
13908 int ecode2 = 0 ;
13909 int val3 ;
13910 int ecode3 = 0 ;
13911 int val4 ;
13912 int ecode4 = 0 ;
13913 PyObject * obj0 = 0 ;
13914 PyObject * obj1 = 0 ;
13915 PyObject * obj2 = 0 ;
13916 PyObject * obj3 = 0 ;
13917 char * kwnames[] = {
13918 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13919 };
13920
13921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13923 if (!SWIG_IsOK(res1)) {
13924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13925 }
13926 arg1 = reinterpret_cast< wxImage * >(argp1);
13927 ecode2 = SWIG_AsVal_int(obj1, &val2);
13928 if (!SWIG_IsOK(ecode2)) {
13929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13930 }
13931 arg2 = static_cast< int >(val2);
13932 ecode3 = SWIG_AsVal_int(obj2, &val3);
13933 if (!SWIG_IsOK(ecode3)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13935 }
13936 arg3 = static_cast< int >(val3);
13937 if (obj3) {
13938 ecode4 = SWIG_AsVal_int(obj3, &val4);
13939 if (!SWIG_IsOK(ecode4)) {
13940 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13941 }
13942 arg4 = static_cast< int >(val4);
13943 }
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 result = (arg1)->Scale(arg2,arg3,arg4);
13947 wxPyEndAllowThreads(__tstate);
13948 if (PyErr_Occurred()) SWIG_fail;
13949 }
13950 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13951 return resultobj;
13952 fail:
13953 return NULL;
13954 }
13955
13956
13957 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13958 PyObject *resultobj = 0;
13959 wxImage *arg1 = (wxImage *) 0 ;
13960 int arg2 ;
13961 int arg3 ;
13962 SwigValueWrapper<wxImage > result;
13963 void *argp1 = 0 ;
13964 int res1 = 0 ;
13965 int val2 ;
13966 int ecode2 = 0 ;
13967 int val3 ;
13968 int ecode3 = 0 ;
13969 PyObject * obj0 = 0 ;
13970 PyObject * obj1 = 0 ;
13971 PyObject * obj2 = 0 ;
13972 char * kwnames[] = {
13973 (char *) "self",(char *) "width",(char *) "height", NULL
13974 };
13975
13976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13978 if (!SWIG_IsOK(res1)) {
13979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13980 }
13981 arg1 = reinterpret_cast< wxImage * >(argp1);
13982 ecode2 = SWIG_AsVal_int(obj1, &val2);
13983 if (!SWIG_IsOK(ecode2)) {
13984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13985 }
13986 arg2 = static_cast< int >(val2);
13987 ecode3 = SWIG_AsVal_int(obj2, &val3);
13988 if (!SWIG_IsOK(ecode3)) {
13989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13990 }
13991 arg3 = static_cast< int >(val3);
13992 {
13993 PyThreadState* __tstate = wxPyBeginAllowThreads();
13994 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13995 wxPyEndAllowThreads(__tstate);
13996 if (PyErr_Occurred()) SWIG_fail;
13997 }
13998 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13999 return resultobj;
14000 fail:
14001 return NULL;
14002 }
14003
14004
14005 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14006 PyObject *resultobj = 0;
14007 wxImage *arg1 = (wxImage *) 0 ;
14008 int arg2 ;
14009 int arg3 ;
14010 SwigValueWrapper<wxImage > result;
14011 void *argp1 = 0 ;
14012 int res1 = 0 ;
14013 int val2 ;
14014 int ecode2 = 0 ;
14015 int val3 ;
14016 int ecode3 = 0 ;
14017 PyObject * obj0 = 0 ;
14018 PyObject * obj1 = 0 ;
14019 PyObject * obj2 = 0 ;
14020 char * kwnames[] = {
14021 (char *) "self",(char *) "width",(char *) "height", NULL
14022 };
14023
14024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14026 if (!SWIG_IsOK(res1)) {
14027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14028 }
14029 arg1 = reinterpret_cast< wxImage * >(argp1);
14030 ecode2 = SWIG_AsVal_int(obj1, &val2);
14031 if (!SWIG_IsOK(ecode2)) {
14032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14033 }
14034 arg2 = static_cast< int >(val2);
14035 ecode3 = SWIG_AsVal_int(obj2, &val3);
14036 if (!SWIG_IsOK(ecode3)) {
14037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14038 }
14039 arg3 = static_cast< int >(val3);
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14043 wxPyEndAllowThreads(__tstate);
14044 if (PyErr_Occurred()) SWIG_fail;
14045 }
14046 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14047 return resultobj;
14048 fail:
14049 return NULL;
14050 }
14051
14052
14053 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14054 PyObject *resultobj = 0;
14055 wxImage *arg1 = (wxImage *) 0 ;
14056 int arg2 ;
14057 SwigValueWrapper<wxImage > result;
14058 void *argp1 = 0 ;
14059 int res1 = 0 ;
14060 int val2 ;
14061 int ecode2 = 0 ;
14062 PyObject * obj0 = 0 ;
14063 PyObject * obj1 = 0 ;
14064 char * kwnames[] = {
14065 (char *) "self",(char *) "radius", NULL
14066 };
14067
14068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14070 if (!SWIG_IsOK(res1)) {
14071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14072 }
14073 arg1 = reinterpret_cast< wxImage * >(argp1);
14074 ecode2 = SWIG_AsVal_int(obj1, &val2);
14075 if (!SWIG_IsOK(ecode2)) {
14076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14077 }
14078 arg2 = static_cast< int >(val2);
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 result = (arg1)->Blur(arg2);
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14086 return resultobj;
14087 fail:
14088 return NULL;
14089 }
14090
14091
14092 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14093 PyObject *resultobj = 0;
14094 wxImage *arg1 = (wxImage *) 0 ;
14095 int arg2 ;
14096 SwigValueWrapper<wxImage > result;
14097 void *argp1 = 0 ;
14098 int res1 = 0 ;
14099 int val2 ;
14100 int ecode2 = 0 ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 char * kwnames[] = {
14104 (char *) "self",(char *) "radius", NULL
14105 };
14106
14107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14109 if (!SWIG_IsOK(res1)) {
14110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14111 }
14112 arg1 = reinterpret_cast< wxImage * >(argp1);
14113 ecode2 = SWIG_AsVal_int(obj1, &val2);
14114 if (!SWIG_IsOK(ecode2)) {
14115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14116 }
14117 arg2 = static_cast< int >(val2);
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 result = (arg1)->BlurHorizontal(arg2);
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14125 return resultobj;
14126 fail:
14127 return NULL;
14128 }
14129
14130
14131 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14132 PyObject *resultobj = 0;
14133 wxImage *arg1 = (wxImage *) 0 ;
14134 int arg2 ;
14135 SwigValueWrapper<wxImage > result;
14136 void *argp1 = 0 ;
14137 int res1 = 0 ;
14138 int val2 ;
14139 int ecode2 = 0 ;
14140 PyObject * obj0 = 0 ;
14141 PyObject * obj1 = 0 ;
14142 char * kwnames[] = {
14143 (char *) "self",(char *) "radius", NULL
14144 };
14145
14146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14148 if (!SWIG_IsOK(res1)) {
14149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14150 }
14151 arg1 = reinterpret_cast< wxImage * >(argp1);
14152 ecode2 = SWIG_AsVal_int(obj1, &val2);
14153 if (!SWIG_IsOK(ecode2)) {
14154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14155 }
14156 arg2 = static_cast< int >(val2);
14157 {
14158 PyThreadState* __tstate = wxPyBeginAllowThreads();
14159 result = (arg1)->BlurVertical(arg2);
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14164 return resultobj;
14165 fail:
14166 return NULL;
14167 }
14168
14169
14170 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14171 PyObject *resultobj = 0;
14172 wxImage *arg1 = (wxImage *) 0 ;
14173 int arg2 ;
14174 int arg3 ;
14175 SwigValueWrapper<wxImage > result;
14176 void *argp1 = 0 ;
14177 int res1 = 0 ;
14178 int val2 ;
14179 int ecode2 = 0 ;
14180 int val3 ;
14181 int ecode3 = 0 ;
14182 PyObject * obj0 = 0 ;
14183 PyObject * obj1 = 0 ;
14184 PyObject * obj2 = 0 ;
14185 char * kwnames[] = {
14186 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14187 };
14188
14189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14191 if (!SWIG_IsOK(res1)) {
14192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14193 }
14194 arg1 = reinterpret_cast< wxImage * >(argp1);
14195 ecode2 = SWIG_AsVal_int(obj1, &val2);
14196 if (!SWIG_IsOK(ecode2)) {
14197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14198 }
14199 arg2 = static_cast< int >(val2);
14200 ecode3 = SWIG_AsVal_int(obj2, &val3);
14201 if (!SWIG_IsOK(ecode3)) {
14202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14203 }
14204 arg3 = static_cast< int >(val3);
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14212 return resultobj;
14213 fail:
14214 return NULL;
14215 }
14216
14217
14218 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14219 PyObject *resultobj = 0;
14220 wxImage *arg1 = (wxImage *) 0 ;
14221 int arg2 ;
14222 int arg3 ;
14223 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14224 wxImage *result = 0 ;
14225 void *argp1 = 0 ;
14226 int res1 = 0 ;
14227 int val2 ;
14228 int ecode2 = 0 ;
14229 int val3 ;
14230 int ecode3 = 0 ;
14231 int val4 ;
14232 int ecode4 = 0 ;
14233 PyObject * obj0 = 0 ;
14234 PyObject * obj1 = 0 ;
14235 PyObject * obj2 = 0 ;
14236 PyObject * obj3 = 0 ;
14237 char * kwnames[] = {
14238 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14239 };
14240
14241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14243 if (!SWIG_IsOK(res1)) {
14244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14245 }
14246 arg1 = reinterpret_cast< wxImage * >(argp1);
14247 ecode2 = SWIG_AsVal_int(obj1, &val2);
14248 if (!SWIG_IsOK(ecode2)) {
14249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14250 }
14251 arg2 = static_cast< int >(val2);
14252 ecode3 = SWIG_AsVal_int(obj2, &val3);
14253 if (!SWIG_IsOK(ecode3)) {
14254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14255 }
14256 arg3 = static_cast< int >(val3);
14257 if (obj3) {
14258 ecode4 = SWIG_AsVal_int(obj3, &val4);
14259 if (!SWIG_IsOK(ecode4)) {
14260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14261 }
14262 arg4 = static_cast< int >(val4);
14263 }
14264 {
14265 PyThreadState* __tstate = wxPyBeginAllowThreads();
14266 {
14267 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14268 result = (wxImage *) &_result_ref;
14269 }
14270 wxPyEndAllowThreads(__tstate);
14271 if (PyErr_Occurred()) SWIG_fail;
14272 }
14273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14274 return resultobj;
14275 fail:
14276 return NULL;
14277 }
14278
14279
14280 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14281 PyObject *resultobj = 0;
14282 wxImage *arg1 = (wxImage *) 0 ;
14283 wxSize *arg2 = 0 ;
14284 wxPoint *arg3 = 0 ;
14285 int arg4 = (int) -1 ;
14286 int arg5 = (int) -1 ;
14287 int arg6 = (int) -1 ;
14288 wxImage *result = 0 ;
14289 void *argp1 = 0 ;
14290 int res1 = 0 ;
14291 wxSize temp2 ;
14292 wxPoint temp3 ;
14293 int val4 ;
14294 int ecode4 = 0 ;
14295 int val5 ;
14296 int ecode5 = 0 ;
14297 int val6 ;
14298 int ecode6 = 0 ;
14299 PyObject * obj0 = 0 ;
14300 PyObject * obj1 = 0 ;
14301 PyObject * obj2 = 0 ;
14302 PyObject * obj3 = 0 ;
14303 PyObject * obj4 = 0 ;
14304 PyObject * obj5 = 0 ;
14305 char * kwnames[] = {
14306 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14307 };
14308
14309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14311 if (!SWIG_IsOK(res1)) {
14312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14313 }
14314 arg1 = reinterpret_cast< wxImage * >(argp1);
14315 {
14316 arg2 = &temp2;
14317 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14318 }
14319 {
14320 arg3 = &temp3;
14321 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14322 }
14323 if (obj3) {
14324 ecode4 = SWIG_AsVal_int(obj3, &val4);
14325 if (!SWIG_IsOK(ecode4)) {
14326 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14327 }
14328 arg4 = static_cast< int >(val4);
14329 }
14330 if (obj4) {
14331 ecode5 = SWIG_AsVal_int(obj4, &val5);
14332 if (!SWIG_IsOK(ecode5)) {
14333 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14334 }
14335 arg5 = static_cast< int >(val5);
14336 }
14337 if (obj5) {
14338 ecode6 = SWIG_AsVal_int(obj5, &val6);
14339 if (!SWIG_IsOK(ecode6)) {
14340 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14341 }
14342 arg6 = static_cast< int >(val6);
14343 }
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 {
14347 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14348 result = (wxImage *) &_result_ref;
14349 }
14350 wxPyEndAllowThreads(__tstate);
14351 if (PyErr_Occurred()) SWIG_fail;
14352 }
14353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14354 return resultobj;
14355 fail:
14356 return NULL;
14357 }
14358
14359
14360 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14361 PyObject *resultobj = 0;
14362 wxImage *arg1 = (wxImage *) 0 ;
14363 int arg2 ;
14364 int arg3 ;
14365 byte arg4 ;
14366 byte arg5 ;
14367 byte arg6 ;
14368 void *argp1 = 0 ;
14369 int res1 = 0 ;
14370 int val2 ;
14371 int ecode2 = 0 ;
14372 int val3 ;
14373 int ecode3 = 0 ;
14374 unsigned char val4 ;
14375 int ecode4 = 0 ;
14376 unsigned char val5 ;
14377 int ecode5 = 0 ;
14378 unsigned char val6 ;
14379 int ecode6 = 0 ;
14380 PyObject * obj0 = 0 ;
14381 PyObject * obj1 = 0 ;
14382 PyObject * obj2 = 0 ;
14383 PyObject * obj3 = 0 ;
14384 PyObject * obj4 = 0 ;
14385 PyObject * obj5 = 0 ;
14386 char * kwnames[] = {
14387 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14388 };
14389
14390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14392 if (!SWIG_IsOK(res1)) {
14393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14394 }
14395 arg1 = reinterpret_cast< wxImage * >(argp1);
14396 ecode2 = SWIG_AsVal_int(obj1, &val2);
14397 if (!SWIG_IsOK(ecode2)) {
14398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14399 }
14400 arg2 = static_cast< int >(val2);
14401 ecode3 = SWIG_AsVal_int(obj2, &val3);
14402 if (!SWIG_IsOK(ecode3)) {
14403 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14404 }
14405 arg3 = static_cast< int >(val3);
14406 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14407 if (!SWIG_IsOK(ecode4)) {
14408 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14409 }
14410 arg4 = static_cast< byte >(val4);
14411 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14412 if (!SWIG_IsOK(ecode5)) {
14413 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14414 }
14415 arg5 = static_cast< byte >(val5);
14416 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14417 if (!SWIG_IsOK(ecode6)) {
14418 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14419 }
14420 arg6 = static_cast< byte >(val6);
14421 {
14422 PyThreadState* __tstate = wxPyBeginAllowThreads();
14423 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14424 wxPyEndAllowThreads(__tstate);
14425 if (PyErr_Occurred()) SWIG_fail;
14426 }
14427 resultobj = SWIG_Py_Void();
14428 return resultobj;
14429 fail:
14430 return NULL;
14431 }
14432
14433
14434 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14435 PyObject *resultobj = 0;
14436 wxImage *arg1 = (wxImage *) 0 ;
14437 wxRect *arg2 = 0 ;
14438 byte arg3 ;
14439 byte arg4 ;
14440 byte arg5 ;
14441 void *argp1 = 0 ;
14442 int res1 = 0 ;
14443 wxRect temp2 ;
14444 unsigned char val3 ;
14445 int ecode3 = 0 ;
14446 unsigned char val4 ;
14447 int ecode4 = 0 ;
14448 unsigned char val5 ;
14449 int ecode5 = 0 ;
14450 PyObject * obj0 = 0 ;
14451 PyObject * obj1 = 0 ;
14452 PyObject * obj2 = 0 ;
14453 PyObject * obj3 = 0 ;
14454 PyObject * obj4 = 0 ;
14455 char * kwnames[] = {
14456 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14457 };
14458
14459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14461 if (!SWIG_IsOK(res1)) {
14462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14463 }
14464 arg1 = reinterpret_cast< wxImage * >(argp1);
14465 {
14466 arg2 = &temp2;
14467 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14468 }
14469 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14470 if (!SWIG_IsOK(ecode3)) {
14471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14472 }
14473 arg3 = static_cast< byte >(val3);
14474 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14475 if (!SWIG_IsOK(ecode4)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14477 }
14478 arg4 = static_cast< byte >(val4);
14479 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14480 if (!SWIG_IsOK(ecode5)) {
14481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14482 }
14483 arg5 = static_cast< byte >(val5);
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 resultobj = SWIG_Py_Void();
14491 return resultobj;
14492 fail:
14493 return NULL;
14494 }
14495
14496
14497 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14498 PyObject *resultobj = 0;
14499 wxImage *arg1 = (wxImage *) 0 ;
14500 int arg2 ;
14501 int arg3 ;
14502 byte result;
14503 void *argp1 = 0 ;
14504 int res1 = 0 ;
14505 int val2 ;
14506 int ecode2 = 0 ;
14507 int val3 ;
14508 int ecode3 = 0 ;
14509 PyObject * obj0 = 0 ;
14510 PyObject * obj1 = 0 ;
14511 PyObject * obj2 = 0 ;
14512 char * kwnames[] = {
14513 (char *) "self",(char *) "x",(char *) "y", NULL
14514 };
14515
14516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14518 if (!SWIG_IsOK(res1)) {
14519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14520 }
14521 arg1 = reinterpret_cast< wxImage * >(argp1);
14522 ecode2 = SWIG_AsVal_int(obj1, &val2);
14523 if (!SWIG_IsOK(ecode2)) {
14524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14525 }
14526 arg2 = static_cast< int >(val2);
14527 ecode3 = SWIG_AsVal_int(obj2, &val3);
14528 if (!SWIG_IsOK(ecode3)) {
14529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14530 }
14531 arg3 = static_cast< int >(val3);
14532 {
14533 PyThreadState* __tstate = wxPyBeginAllowThreads();
14534 result = (byte)(arg1)->GetRed(arg2,arg3);
14535 wxPyEndAllowThreads(__tstate);
14536 if (PyErr_Occurred()) SWIG_fail;
14537 }
14538 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14539 return resultobj;
14540 fail:
14541 return NULL;
14542 }
14543
14544
14545 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14546 PyObject *resultobj = 0;
14547 wxImage *arg1 = (wxImage *) 0 ;
14548 int arg2 ;
14549 int arg3 ;
14550 byte result;
14551 void *argp1 = 0 ;
14552 int res1 = 0 ;
14553 int val2 ;
14554 int ecode2 = 0 ;
14555 int val3 ;
14556 int ecode3 = 0 ;
14557 PyObject * obj0 = 0 ;
14558 PyObject * obj1 = 0 ;
14559 PyObject * obj2 = 0 ;
14560 char * kwnames[] = {
14561 (char *) "self",(char *) "x",(char *) "y", NULL
14562 };
14563
14564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14566 if (!SWIG_IsOK(res1)) {
14567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14568 }
14569 arg1 = reinterpret_cast< wxImage * >(argp1);
14570 ecode2 = SWIG_AsVal_int(obj1, &val2);
14571 if (!SWIG_IsOK(ecode2)) {
14572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14573 }
14574 arg2 = static_cast< int >(val2);
14575 ecode3 = SWIG_AsVal_int(obj2, &val3);
14576 if (!SWIG_IsOK(ecode3)) {
14577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14578 }
14579 arg3 = static_cast< int >(val3);
14580 {
14581 PyThreadState* __tstate = wxPyBeginAllowThreads();
14582 result = (byte)(arg1)->GetGreen(arg2,arg3);
14583 wxPyEndAllowThreads(__tstate);
14584 if (PyErr_Occurred()) SWIG_fail;
14585 }
14586 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14587 return resultobj;
14588 fail:
14589 return NULL;
14590 }
14591
14592
14593 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14594 PyObject *resultobj = 0;
14595 wxImage *arg1 = (wxImage *) 0 ;
14596 int arg2 ;
14597 int arg3 ;
14598 byte result;
14599 void *argp1 = 0 ;
14600 int res1 = 0 ;
14601 int val2 ;
14602 int ecode2 = 0 ;
14603 int val3 ;
14604 int ecode3 = 0 ;
14605 PyObject * obj0 = 0 ;
14606 PyObject * obj1 = 0 ;
14607 PyObject * obj2 = 0 ;
14608 char * kwnames[] = {
14609 (char *) "self",(char *) "x",(char *) "y", NULL
14610 };
14611
14612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14614 if (!SWIG_IsOK(res1)) {
14615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14616 }
14617 arg1 = reinterpret_cast< wxImage * >(argp1);
14618 ecode2 = SWIG_AsVal_int(obj1, &val2);
14619 if (!SWIG_IsOK(ecode2)) {
14620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14621 }
14622 arg2 = static_cast< int >(val2);
14623 ecode3 = SWIG_AsVal_int(obj2, &val3);
14624 if (!SWIG_IsOK(ecode3)) {
14625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14626 }
14627 arg3 = static_cast< int >(val3);
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 result = (byte)(arg1)->GetBlue(arg2,arg3);
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14635 return resultobj;
14636 fail:
14637 return NULL;
14638 }
14639
14640
14641 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14642 PyObject *resultobj = 0;
14643 wxImage *arg1 = (wxImage *) 0 ;
14644 int arg2 ;
14645 int arg3 ;
14646 byte arg4 ;
14647 void *argp1 = 0 ;
14648 int res1 = 0 ;
14649 int val2 ;
14650 int ecode2 = 0 ;
14651 int val3 ;
14652 int ecode3 = 0 ;
14653 unsigned char val4 ;
14654 int ecode4 = 0 ;
14655 PyObject * obj0 = 0 ;
14656 PyObject * obj1 = 0 ;
14657 PyObject * obj2 = 0 ;
14658 PyObject * obj3 = 0 ;
14659 char * kwnames[] = {
14660 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14661 };
14662
14663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14665 if (!SWIG_IsOK(res1)) {
14666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14667 }
14668 arg1 = reinterpret_cast< wxImage * >(argp1);
14669 ecode2 = SWIG_AsVal_int(obj1, &val2);
14670 if (!SWIG_IsOK(ecode2)) {
14671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14672 }
14673 arg2 = static_cast< int >(val2);
14674 ecode3 = SWIG_AsVal_int(obj2, &val3);
14675 if (!SWIG_IsOK(ecode3)) {
14676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14677 }
14678 arg3 = static_cast< int >(val3);
14679 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14680 if (!SWIG_IsOK(ecode4)) {
14681 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14682 }
14683 arg4 = static_cast< byte >(val4);
14684 {
14685 PyThreadState* __tstate = wxPyBeginAllowThreads();
14686 (arg1)->SetAlpha(arg2,arg3,arg4);
14687 wxPyEndAllowThreads(__tstate);
14688 if (PyErr_Occurred()) SWIG_fail;
14689 }
14690 resultobj = SWIG_Py_Void();
14691 return resultobj;
14692 fail:
14693 return NULL;
14694 }
14695
14696
14697 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14698 PyObject *resultobj = 0;
14699 wxImage *arg1 = (wxImage *) 0 ;
14700 int arg2 ;
14701 int arg3 ;
14702 byte result;
14703 void *argp1 = 0 ;
14704 int res1 = 0 ;
14705 int val2 ;
14706 int ecode2 = 0 ;
14707 int val3 ;
14708 int ecode3 = 0 ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 PyObject * obj2 = 0 ;
14712 char * kwnames[] = {
14713 (char *) "self",(char *) "x",(char *) "y", NULL
14714 };
14715
14716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14720 }
14721 arg1 = reinterpret_cast< wxImage * >(argp1);
14722 ecode2 = SWIG_AsVal_int(obj1, &val2);
14723 if (!SWIG_IsOK(ecode2)) {
14724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14725 }
14726 arg2 = static_cast< int >(val2);
14727 ecode3 = SWIG_AsVal_int(obj2, &val3);
14728 if (!SWIG_IsOK(ecode3)) {
14729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14730 }
14731 arg3 = static_cast< int >(val3);
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14739 return resultobj;
14740 fail:
14741 return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14746 PyObject *resultobj = 0;
14747 wxImage *arg1 = (wxImage *) 0 ;
14748 bool result;
14749 void *argp1 = 0 ;
14750 int res1 = 0 ;
14751 PyObject *swig_obj[1] ;
14752
14753 if (!args) SWIG_fail;
14754 swig_obj[0] = args;
14755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14756 if (!SWIG_IsOK(res1)) {
14757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14758 }
14759 arg1 = reinterpret_cast< wxImage * >(argp1);
14760 {
14761 PyThreadState* __tstate = wxPyBeginAllowThreads();
14762 result = (bool)(arg1)->HasAlpha();
14763 wxPyEndAllowThreads(__tstate);
14764 if (PyErr_Occurred()) SWIG_fail;
14765 }
14766 {
14767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14768 }
14769 return resultobj;
14770 fail:
14771 return NULL;
14772 }
14773
14774
14775 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14776 PyObject *resultobj = 0;
14777 wxImage *arg1 = (wxImage *) 0 ;
14778 void *argp1 = 0 ;
14779 int res1 = 0 ;
14780 PyObject *swig_obj[1] ;
14781
14782 if (!args) SWIG_fail;
14783 swig_obj[0] = args;
14784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14785 if (!SWIG_IsOK(res1)) {
14786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14787 }
14788 arg1 = reinterpret_cast< wxImage * >(argp1);
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 (arg1)->InitAlpha();
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 resultobj = SWIG_Py_Void();
14796 return resultobj;
14797 fail:
14798 return NULL;
14799 }
14800
14801
14802 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14803 PyObject *resultobj = 0;
14804 wxImage *arg1 = (wxImage *) 0 ;
14805 int arg2 ;
14806 int arg3 ;
14807 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14808 bool result;
14809 void *argp1 = 0 ;
14810 int res1 = 0 ;
14811 int val2 ;
14812 int ecode2 = 0 ;
14813 int val3 ;
14814 int ecode3 = 0 ;
14815 unsigned char val4 ;
14816 int ecode4 = 0 ;
14817 PyObject * obj0 = 0 ;
14818 PyObject * obj1 = 0 ;
14819 PyObject * obj2 = 0 ;
14820 PyObject * obj3 = 0 ;
14821 char * kwnames[] = {
14822 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14823 };
14824
14825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14827 if (!SWIG_IsOK(res1)) {
14828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14829 }
14830 arg1 = reinterpret_cast< wxImage * >(argp1);
14831 ecode2 = SWIG_AsVal_int(obj1, &val2);
14832 if (!SWIG_IsOK(ecode2)) {
14833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14834 }
14835 arg2 = static_cast< int >(val2);
14836 ecode3 = SWIG_AsVal_int(obj2, &val3);
14837 if (!SWIG_IsOK(ecode3)) {
14838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14839 }
14840 arg3 = static_cast< int >(val3);
14841 if (obj3) {
14842 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14843 if (!SWIG_IsOK(ecode4)) {
14844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14845 }
14846 arg4 = static_cast< byte >(val4);
14847 }
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14851 wxPyEndAllowThreads(__tstate);
14852 if (PyErr_Occurred()) SWIG_fail;
14853 }
14854 {
14855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14856 }
14857 return resultobj;
14858 fail:
14859 return NULL;
14860 }
14861
14862
14863 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj = 0;
14865 wxImage *arg1 = (wxImage *) 0 ;
14866 byte *arg2 = (byte *) 0 ;
14867 byte *arg3 = (byte *) 0 ;
14868 byte *arg4 = (byte *) 0 ;
14869 byte arg5 = (byte) 0 ;
14870 byte arg6 = (byte) 0 ;
14871 byte arg7 = (byte) 0 ;
14872 bool result;
14873 void *argp1 = 0 ;
14874 int res1 = 0 ;
14875 byte temp2 ;
14876 int res2 = SWIG_TMPOBJ ;
14877 byte temp3 ;
14878 int res3 = SWIG_TMPOBJ ;
14879 byte temp4 ;
14880 int res4 = SWIG_TMPOBJ ;
14881 unsigned char val5 ;
14882 int ecode5 = 0 ;
14883 unsigned char val6 ;
14884 int ecode6 = 0 ;
14885 unsigned char val7 ;
14886 int ecode7 = 0 ;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 PyObject * obj2 = 0 ;
14890 PyObject * obj3 = 0 ;
14891 char * kwnames[] = {
14892 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14893 };
14894
14895 arg2 = &temp2;
14896 arg3 = &temp3;
14897 arg4 = &temp4;
14898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14900 if (!SWIG_IsOK(res1)) {
14901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14902 }
14903 arg1 = reinterpret_cast< wxImage * >(argp1);
14904 if (obj1) {
14905 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14906 if (!SWIG_IsOK(ecode5)) {
14907 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14908 }
14909 arg5 = static_cast< byte >(val5);
14910 }
14911 if (obj2) {
14912 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14913 if (!SWIG_IsOK(ecode6)) {
14914 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14915 }
14916 arg6 = static_cast< byte >(val6);
14917 }
14918 if (obj3) {
14919 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14920 if (!SWIG_IsOK(ecode7)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14922 }
14923 arg7 = static_cast< byte >(val7);
14924 }
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14928 wxPyEndAllowThreads(__tstate);
14929 if (PyErr_Occurred()) SWIG_fail;
14930 }
14931 {
14932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14933 }
14934 if (SWIG_IsTmpObj(res2)) {
14935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14936 } else {
14937 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14939 }
14940 if (SWIG_IsTmpObj(res3)) {
14941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14942 } else {
14943 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14945 }
14946 if (SWIG_IsTmpObj(res4)) {
14947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14948 } else {
14949 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14951 }
14952 return resultobj;
14953 fail:
14954 return NULL;
14955 }
14956
14957
14958 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14959 PyObject *resultobj = 0;
14960 wxImage *arg1 = (wxImage *) 0 ;
14961 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14962 bool result;
14963 void *argp1 = 0 ;
14964 int res1 = 0 ;
14965 unsigned char val2 ;
14966 int ecode2 = 0 ;
14967 PyObject * obj0 = 0 ;
14968 PyObject * obj1 = 0 ;
14969 char * kwnames[] = {
14970 (char *) "self",(char *) "threshold", NULL
14971 };
14972
14973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14975 if (!SWIG_IsOK(res1)) {
14976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14977 }
14978 arg1 = reinterpret_cast< wxImage * >(argp1);
14979 if (obj1) {
14980 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14981 if (!SWIG_IsOK(ecode2)) {
14982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14983 }
14984 arg2 = static_cast< byte >(val2);
14985 }
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14989 wxPyEndAllowThreads(__tstate);
14990 if (PyErr_Occurred()) SWIG_fail;
14991 }
14992 {
14993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14994 }
14995 return resultobj;
14996 fail:
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj = 0;
15003 wxImage *arg1 = (wxImage *) 0 ;
15004 byte arg2 ;
15005 byte arg3 ;
15006 byte arg4 ;
15007 bool result;
15008 void *argp1 = 0 ;
15009 int res1 = 0 ;
15010 unsigned char val2 ;
15011 int ecode2 = 0 ;
15012 unsigned char val3 ;
15013 int ecode3 = 0 ;
15014 unsigned char val4 ;
15015 int ecode4 = 0 ;
15016 PyObject * obj0 = 0 ;
15017 PyObject * obj1 = 0 ;
15018 PyObject * obj2 = 0 ;
15019 PyObject * obj3 = 0 ;
15020 char * kwnames[] = {
15021 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15022 };
15023
15024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15028 }
15029 arg1 = reinterpret_cast< wxImage * >(argp1);
15030 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15031 if (!SWIG_IsOK(ecode2)) {
15032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15033 }
15034 arg2 = static_cast< byte >(val2);
15035 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15036 if (!SWIG_IsOK(ecode3)) {
15037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15038 }
15039 arg3 = static_cast< byte >(val3);
15040 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15041 if (!SWIG_IsOK(ecode4)) {
15042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15043 }
15044 arg4 = static_cast< byte >(val4);
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 {
15052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15053 }
15054 return resultobj;
15055 fail:
15056 return NULL;
15057 }
15058
15059
15060 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15061 PyObject *resultobj = 0;
15062 wxImage *arg1 = (wxImage *) 0 ;
15063 wxImage *arg2 = 0 ;
15064 byte arg3 ;
15065 byte arg4 ;
15066 byte arg5 ;
15067 bool result;
15068 void *argp1 = 0 ;
15069 int res1 = 0 ;
15070 void *argp2 = 0 ;
15071 int res2 = 0 ;
15072 unsigned char val3 ;
15073 int ecode3 = 0 ;
15074 unsigned char val4 ;
15075 int ecode4 = 0 ;
15076 unsigned char val5 ;
15077 int ecode5 = 0 ;
15078 PyObject * obj0 = 0 ;
15079 PyObject * obj1 = 0 ;
15080 PyObject * obj2 = 0 ;
15081 PyObject * obj3 = 0 ;
15082 PyObject * obj4 = 0 ;
15083 char * kwnames[] = {
15084 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15085 };
15086
15087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15089 if (!SWIG_IsOK(res1)) {
15090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15091 }
15092 arg1 = reinterpret_cast< wxImage * >(argp1);
15093 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15094 if (!SWIG_IsOK(res2)) {
15095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15096 }
15097 if (!argp2) {
15098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15099 }
15100 arg2 = reinterpret_cast< wxImage * >(argp2);
15101 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15102 if (!SWIG_IsOK(ecode3)) {
15103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15104 }
15105 arg3 = static_cast< byte >(val3);
15106 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15107 if (!SWIG_IsOK(ecode4)) {
15108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15109 }
15110 arg4 = static_cast< byte >(val4);
15111 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15112 if (!SWIG_IsOK(ecode5)) {
15113 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15114 }
15115 arg5 = static_cast< byte >(val5);
15116 {
15117 PyThreadState* __tstate = wxPyBeginAllowThreads();
15118 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15119 wxPyEndAllowThreads(__tstate);
15120 if (PyErr_Occurred()) SWIG_fail;
15121 }
15122 {
15123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15124 }
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15132 PyObject *resultobj = 0;
15133 wxString *arg1 = 0 ;
15134 bool result;
15135 bool temp1 = false ;
15136 PyObject * obj0 = 0 ;
15137 char * kwnames[] = {
15138 (char *) "filename", NULL
15139 };
15140
15141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15142 {
15143 arg1 = wxString_in_helper(obj0);
15144 if (arg1 == NULL) SWIG_fail;
15145 temp1 = true;
15146 }
15147 {
15148 PyThreadState* __tstate = wxPyBeginAllowThreads();
15149 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 {
15154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15155 }
15156 {
15157 if (temp1)
15158 delete arg1;
15159 }
15160 return resultobj;
15161 fail:
15162 {
15163 if (temp1)
15164 delete arg1;
15165 }
15166 return NULL;
15167 }
15168
15169
15170 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15171 PyObject *resultobj = 0;
15172 wxString *arg1 = 0 ;
15173 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15174 int result;
15175 bool temp1 = false ;
15176 long val2 ;
15177 int ecode2 = 0 ;
15178 PyObject * obj0 = 0 ;
15179 PyObject * obj1 = 0 ;
15180 char * kwnames[] = {
15181 (char *) "filename",(char *) "type", NULL
15182 };
15183
15184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15185 {
15186 arg1 = wxString_in_helper(obj0);
15187 if (arg1 == NULL) SWIG_fail;
15188 temp1 = true;
15189 }
15190 if (obj1) {
15191 ecode2 = SWIG_AsVal_long(obj1, &val2);
15192 if (!SWIG_IsOK(ecode2)) {
15193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15194 }
15195 arg2 = static_cast< long >(val2);
15196 }
15197 {
15198 PyThreadState* __tstate = wxPyBeginAllowThreads();
15199 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15200 wxPyEndAllowThreads(__tstate);
15201 if (PyErr_Occurred()) SWIG_fail;
15202 }
15203 resultobj = SWIG_From_int(static_cast< int >(result));
15204 {
15205 if (temp1)
15206 delete arg1;
15207 }
15208 return resultobj;
15209 fail:
15210 {
15211 if (temp1)
15212 delete arg1;
15213 }
15214 return NULL;
15215 }
15216
15217
15218 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15219 PyObject *resultobj = 0;
15220 wxImage *arg1 = (wxImage *) 0 ;
15221 wxString *arg2 = 0 ;
15222 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15223 int arg4 = (int) -1 ;
15224 bool result;
15225 void *argp1 = 0 ;
15226 int res1 = 0 ;
15227 bool temp2 = false ;
15228 long val3 ;
15229 int ecode3 = 0 ;
15230 int val4 ;
15231 int ecode4 = 0 ;
15232 PyObject * obj0 = 0 ;
15233 PyObject * obj1 = 0 ;
15234 PyObject * obj2 = 0 ;
15235 PyObject * obj3 = 0 ;
15236 char * kwnames[] = {
15237 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15238 };
15239
15240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15242 if (!SWIG_IsOK(res1)) {
15243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15244 }
15245 arg1 = reinterpret_cast< wxImage * >(argp1);
15246 {
15247 arg2 = wxString_in_helper(obj1);
15248 if (arg2 == NULL) SWIG_fail;
15249 temp2 = true;
15250 }
15251 if (obj2) {
15252 ecode3 = SWIG_AsVal_long(obj2, &val3);
15253 if (!SWIG_IsOK(ecode3)) {
15254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15255 }
15256 arg3 = static_cast< long >(val3);
15257 }
15258 if (obj3) {
15259 ecode4 = SWIG_AsVal_int(obj3, &val4);
15260 if (!SWIG_IsOK(ecode4)) {
15261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15262 }
15263 arg4 = static_cast< int >(val4);
15264 }
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 {
15272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15273 }
15274 {
15275 if (temp2)
15276 delete arg2;
15277 }
15278 return resultobj;
15279 fail:
15280 {
15281 if (temp2)
15282 delete arg2;
15283 }
15284 return NULL;
15285 }
15286
15287
15288 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15289 PyObject *resultobj = 0;
15290 wxImage *arg1 = (wxImage *) 0 ;
15291 wxString *arg2 = 0 ;
15292 wxString *arg3 = 0 ;
15293 int arg4 = (int) -1 ;
15294 bool result;
15295 void *argp1 = 0 ;
15296 int res1 = 0 ;
15297 bool temp2 = false ;
15298 bool temp3 = false ;
15299 int val4 ;
15300 int ecode4 = 0 ;
15301 PyObject * obj0 = 0 ;
15302 PyObject * obj1 = 0 ;
15303 PyObject * obj2 = 0 ;
15304 PyObject * obj3 = 0 ;
15305 char * kwnames[] = {
15306 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15307 };
15308
15309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15311 if (!SWIG_IsOK(res1)) {
15312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15313 }
15314 arg1 = reinterpret_cast< wxImage * >(argp1);
15315 {
15316 arg2 = wxString_in_helper(obj1);
15317 if (arg2 == NULL) SWIG_fail;
15318 temp2 = true;
15319 }
15320 {
15321 arg3 = wxString_in_helper(obj2);
15322 if (arg3 == NULL) SWIG_fail;
15323 temp3 = true;
15324 }
15325 if (obj3) {
15326 ecode4 = SWIG_AsVal_int(obj3, &val4);
15327 if (!SWIG_IsOK(ecode4)) {
15328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15329 }
15330 arg4 = static_cast< int >(val4);
15331 }
15332 {
15333 PyThreadState* __tstate = wxPyBeginAllowThreads();
15334 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15335 wxPyEndAllowThreads(__tstate);
15336 if (PyErr_Occurred()) SWIG_fail;
15337 }
15338 {
15339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15340 }
15341 {
15342 if (temp2)
15343 delete arg2;
15344 }
15345 {
15346 if (temp3)
15347 delete arg3;
15348 }
15349 return resultobj;
15350 fail:
15351 {
15352 if (temp2)
15353 delete arg2;
15354 }
15355 {
15356 if (temp3)
15357 delete arg3;
15358 }
15359 return NULL;
15360 }
15361
15362
15363 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15364 PyObject *resultobj = 0;
15365 wxImage *arg1 = (wxImage *) 0 ;
15366 wxString *arg2 = 0 ;
15367 int arg3 ;
15368 bool result;
15369 void *argp1 = 0 ;
15370 int res1 = 0 ;
15371 bool temp2 = false ;
15372 int val3 ;
15373 int ecode3 = 0 ;
15374 PyObject * obj0 = 0 ;
15375 PyObject * obj1 = 0 ;
15376 PyObject * obj2 = 0 ;
15377 char * kwnames[] = {
15378 (char *) "self",(char *) "name",(char *) "type", NULL
15379 };
15380
15381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15383 if (!SWIG_IsOK(res1)) {
15384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15385 }
15386 arg1 = reinterpret_cast< wxImage * >(argp1);
15387 {
15388 arg2 = wxString_in_helper(obj1);
15389 if (arg2 == NULL) SWIG_fail;
15390 temp2 = true;
15391 }
15392 ecode3 = SWIG_AsVal_int(obj2, &val3);
15393 if (!SWIG_IsOK(ecode3)) {
15394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15395 }
15396 arg3 = static_cast< int >(val3);
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15400 wxPyEndAllowThreads(__tstate);
15401 if (PyErr_Occurred()) SWIG_fail;
15402 }
15403 {
15404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15405 }
15406 {
15407 if (temp2)
15408 delete arg2;
15409 }
15410 return resultobj;
15411 fail:
15412 {
15413 if (temp2)
15414 delete arg2;
15415 }
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15421 PyObject *resultobj = 0;
15422 wxImage *arg1 = (wxImage *) 0 ;
15423 wxString *arg2 = 0 ;
15424 wxString *arg3 = 0 ;
15425 bool result;
15426 void *argp1 = 0 ;
15427 int res1 = 0 ;
15428 bool temp2 = false ;
15429 bool temp3 = false ;
15430 PyObject * obj0 = 0 ;
15431 PyObject * obj1 = 0 ;
15432 PyObject * obj2 = 0 ;
15433 char * kwnames[] = {
15434 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15435 };
15436
15437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15439 if (!SWIG_IsOK(res1)) {
15440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15441 }
15442 arg1 = reinterpret_cast< wxImage * >(argp1);
15443 {
15444 arg2 = wxString_in_helper(obj1);
15445 if (arg2 == NULL) SWIG_fail;
15446 temp2 = true;
15447 }
15448 {
15449 arg3 = wxString_in_helper(obj2);
15450 if (arg3 == NULL) SWIG_fail;
15451 temp3 = true;
15452 }
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15456 wxPyEndAllowThreads(__tstate);
15457 if (PyErr_Occurred()) SWIG_fail;
15458 }
15459 {
15460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15461 }
15462 {
15463 if (temp2)
15464 delete arg2;
15465 }
15466 {
15467 if (temp3)
15468 delete arg3;
15469 }
15470 return resultobj;
15471 fail:
15472 {
15473 if (temp2)
15474 delete arg2;
15475 }
15476 {
15477 if (temp3)
15478 delete arg3;
15479 }
15480 return NULL;
15481 }
15482
15483
15484 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15485 PyObject *resultobj = 0;
15486 wxInputStream *arg1 = 0 ;
15487 bool result;
15488 wxPyInputStream *temp1 ;
15489 bool created1 ;
15490 PyObject * obj0 = 0 ;
15491 char * kwnames[] = {
15492 (char *) "stream", NULL
15493 };
15494
15495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15496 {
15497 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15498 arg1 = temp1->m_wxis;
15499 created1 = false;
15500 } else {
15501 PyErr_Clear(); // clear the failure of the wxPyConvert above
15502 arg1 = wxPyCBInputStream_create(obj0, false);
15503 if (arg1 == NULL) {
15504 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15505 SWIG_fail;
15506 }
15507 created1 = true;
15508 }
15509 }
15510 {
15511 PyThreadState* __tstate = wxPyBeginAllowThreads();
15512 result = (bool)wxImage::CanRead(*arg1);
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 {
15517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15518 }
15519 {
15520 if (created1) delete arg1;
15521 }
15522 return resultobj;
15523 fail:
15524 {
15525 if (created1) delete arg1;
15526 }
15527 return NULL;
15528 }
15529
15530
15531 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15532 PyObject *resultobj = 0;
15533 wxImage *arg1 = (wxImage *) 0 ;
15534 wxInputStream *arg2 = 0 ;
15535 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15536 int arg4 = (int) -1 ;
15537 bool result;
15538 void *argp1 = 0 ;
15539 int res1 = 0 ;
15540 wxPyInputStream *temp2 ;
15541 bool created2 ;
15542 long val3 ;
15543 int ecode3 = 0 ;
15544 int val4 ;
15545 int ecode4 = 0 ;
15546 PyObject * obj0 = 0 ;
15547 PyObject * obj1 = 0 ;
15548 PyObject * obj2 = 0 ;
15549 PyObject * obj3 = 0 ;
15550 char * kwnames[] = {
15551 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15552 };
15553
15554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15556 if (!SWIG_IsOK(res1)) {
15557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15558 }
15559 arg1 = reinterpret_cast< wxImage * >(argp1);
15560 {
15561 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15562 arg2 = temp2->m_wxis;
15563 created2 = false;
15564 } else {
15565 PyErr_Clear(); // clear the failure of the wxPyConvert above
15566 arg2 = wxPyCBInputStream_create(obj1, false);
15567 if (arg2 == NULL) {
15568 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15569 SWIG_fail;
15570 }
15571 created2 = true;
15572 }
15573 }
15574 if (obj2) {
15575 ecode3 = SWIG_AsVal_long(obj2, &val3);
15576 if (!SWIG_IsOK(ecode3)) {
15577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15578 }
15579 arg3 = static_cast< long >(val3);
15580 }
15581 if (obj3) {
15582 ecode4 = SWIG_AsVal_int(obj3, &val4);
15583 if (!SWIG_IsOK(ecode4)) {
15584 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15585 }
15586 arg4 = static_cast< int >(val4);
15587 }
15588 {
15589 PyThreadState* __tstate = wxPyBeginAllowThreads();
15590 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15591 wxPyEndAllowThreads(__tstate);
15592 if (PyErr_Occurred()) SWIG_fail;
15593 }
15594 {
15595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15596 }
15597 {
15598 if (created2) delete arg2;
15599 }
15600 return resultobj;
15601 fail:
15602 {
15603 if (created2) delete arg2;
15604 }
15605 return NULL;
15606 }
15607
15608
15609 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15610 PyObject *resultobj = 0;
15611 wxImage *arg1 = (wxImage *) 0 ;
15612 wxInputStream *arg2 = 0 ;
15613 wxString *arg3 = 0 ;
15614 int arg4 = (int) -1 ;
15615 bool result;
15616 void *argp1 = 0 ;
15617 int res1 = 0 ;
15618 wxPyInputStream *temp2 ;
15619 bool created2 ;
15620 bool temp3 = false ;
15621 int val4 ;
15622 int ecode4 = 0 ;
15623 PyObject * obj0 = 0 ;
15624 PyObject * obj1 = 0 ;
15625 PyObject * obj2 = 0 ;
15626 PyObject * obj3 = 0 ;
15627 char * kwnames[] = {
15628 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15629 };
15630
15631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15633 if (!SWIG_IsOK(res1)) {
15634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15635 }
15636 arg1 = reinterpret_cast< wxImage * >(argp1);
15637 {
15638 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15639 arg2 = temp2->m_wxis;
15640 created2 = false;
15641 } else {
15642 PyErr_Clear(); // clear the failure of the wxPyConvert above
15643 arg2 = wxPyCBInputStream_create(obj1, false);
15644 if (arg2 == NULL) {
15645 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15646 SWIG_fail;
15647 }
15648 created2 = true;
15649 }
15650 }
15651 {
15652 arg3 = wxString_in_helper(obj2);
15653 if (arg3 == NULL) SWIG_fail;
15654 temp3 = true;
15655 }
15656 if (obj3) {
15657 ecode4 = SWIG_AsVal_int(obj3, &val4);
15658 if (!SWIG_IsOK(ecode4)) {
15659 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15660 }
15661 arg4 = static_cast< int >(val4);
15662 }
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 {
15670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15671 }
15672 {
15673 if (created2) delete arg2;
15674 }
15675 {
15676 if (temp3)
15677 delete arg3;
15678 }
15679 return resultobj;
15680 fail:
15681 {
15682 if (created2) delete arg2;
15683 }
15684 {
15685 if (temp3)
15686 delete arg3;
15687 }
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15693 PyObject *resultobj = 0;
15694 wxImage *arg1 = (wxImage *) 0 ;
15695 bool result;
15696 void *argp1 = 0 ;
15697 int res1 = 0 ;
15698 PyObject *swig_obj[1] ;
15699
15700 if (!args) SWIG_fail;
15701 swig_obj[0] = args;
15702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15703 if (!SWIG_IsOK(res1)) {
15704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15705 }
15706 arg1 = reinterpret_cast< wxImage * >(argp1);
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 result = (bool)(arg1)->IsOk();
15710 wxPyEndAllowThreads(__tstate);
15711 if (PyErr_Occurred()) SWIG_fail;
15712 }
15713 {
15714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15715 }
15716 return resultobj;
15717 fail:
15718 return NULL;
15719 }
15720
15721
15722 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15723 PyObject *resultobj = 0;
15724 wxImage *arg1 = (wxImage *) 0 ;
15725 int result;
15726 void *argp1 = 0 ;
15727 int res1 = 0 ;
15728 PyObject *swig_obj[1] ;
15729
15730 if (!args) SWIG_fail;
15731 swig_obj[0] = args;
15732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15733 if (!SWIG_IsOK(res1)) {
15734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15735 }
15736 arg1 = reinterpret_cast< wxImage * >(argp1);
15737 {
15738 PyThreadState* __tstate = wxPyBeginAllowThreads();
15739 result = (int)(arg1)->GetWidth();
15740 wxPyEndAllowThreads(__tstate);
15741 if (PyErr_Occurred()) SWIG_fail;
15742 }
15743 resultobj = SWIG_From_int(static_cast< int >(result));
15744 return resultobj;
15745 fail:
15746 return NULL;
15747 }
15748
15749
15750 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15751 PyObject *resultobj = 0;
15752 wxImage *arg1 = (wxImage *) 0 ;
15753 int result;
15754 void *argp1 = 0 ;
15755 int res1 = 0 ;
15756 PyObject *swig_obj[1] ;
15757
15758 if (!args) SWIG_fail;
15759 swig_obj[0] = args;
15760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15761 if (!SWIG_IsOK(res1)) {
15762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15763 }
15764 arg1 = reinterpret_cast< wxImage * >(argp1);
15765 {
15766 PyThreadState* __tstate = wxPyBeginAllowThreads();
15767 result = (int)(arg1)->GetHeight();
15768 wxPyEndAllowThreads(__tstate);
15769 if (PyErr_Occurred()) SWIG_fail;
15770 }
15771 resultobj = SWIG_From_int(static_cast< int >(result));
15772 return resultobj;
15773 fail:
15774 return NULL;
15775 }
15776
15777
15778 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15779 PyObject *resultobj = 0;
15780 wxImage *arg1 = (wxImage *) 0 ;
15781 wxSize result;
15782 void *argp1 = 0 ;
15783 int res1 = 0 ;
15784 PyObject *swig_obj[1] ;
15785
15786 if (!args) SWIG_fail;
15787 swig_obj[0] = args;
15788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15789 if (!SWIG_IsOK(res1)) {
15790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15791 }
15792 arg1 = reinterpret_cast< wxImage * >(argp1);
15793 {
15794 PyThreadState* __tstate = wxPyBeginAllowThreads();
15795 result = wxImage_GetSize(arg1);
15796 wxPyEndAllowThreads(__tstate);
15797 if (PyErr_Occurred()) SWIG_fail;
15798 }
15799 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15800 return resultobj;
15801 fail:
15802 return NULL;
15803 }
15804
15805
15806 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15807 PyObject *resultobj = 0;
15808 wxImage *arg1 = (wxImage *) 0 ;
15809 wxRect *arg2 = 0 ;
15810 SwigValueWrapper<wxImage > result;
15811 void *argp1 = 0 ;
15812 int res1 = 0 ;
15813 wxRect temp2 ;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char * kwnames[] = {
15817 (char *) "self",(char *) "rect", NULL
15818 };
15819
15820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15822 if (!SWIG_IsOK(res1)) {
15823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15824 }
15825 arg1 = reinterpret_cast< wxImage * >(argp1);
15826 {
15827 arg2 = &temp2;
15828 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15829 }
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15844 PyObject *resultobj = 0;
15845 wxImage *arg1 = (wxImage *) 0 ;
15846 wxSize *arg2 = 0 ;
15847 wxPoint *arg3 = 0 ;
15848 int arg4 = (int) -1 ;
15849 int arg5 = (int) -1 ;
15850 int arg6 = (int) -1 ;
15851 SwigValueWrapper<wxImage > result;
15852 void *argp1 = 0 ;
15853 int res1 = 0 ;
15854 wxSize temp2 ;
15855 wxPoint temp3 ;
15856 int val4 ;
15857 int ecode4 = 0 ;
15858 int val5 ;
15859 int ecode5 = 0 ;
15860 int val6 ;
15861 int ecode6 = 0 ;
15862 PyObject * obj0 = 0 ;
15863 PyObject * obj1 = 0 ;
15864 PyObject * obj2 = 0 ;
15865 PyObject * obj3 = 0 ;
15866 PyObject * obj4 = 0 ;
15867 PyObject * obj5 = 0 ;
15868 char * kwnames[] = {
15869 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15870 };
15871
15872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15874 if (!SWIG_IsOK(res1)) {
15875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15876 }
15877 arg1 = reinterpret_cast< wxImage * >(argp1);
15878 {
15879 arg2 = &temp2;
15880 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15881 }
15882 {
15883 arg3 = &temp3;
15884 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15885 }
15886 if (obj3) {
15887 ecode4 = SWIG_AsVal_int(obj3, &val4);
15888 if (!SWIG_IsOK(ecode4)) {
15889 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15890 }
15891 arg4 = static_cast< int >(val4);
15892 }
15893 if (obj4) {
15894 ecode5 = SWIG_AsVal_int(obj4, &val5);
15895 if (!SWIG_IsOK(ecode5)) {
15896 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15897 }
15898 arg5 = static_cast< int >(val5);
15899 }
15900 if (obj5) {
15901 ecode6 = SWIG_AsVal_int(obj5, &val6);
15902 if (!SWIG_IsOK(ecode6)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15904 }
15905 arg6 = static_cast< int >(val6);
15906 }
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15921 PyObject *resultobj = 0;
15922 wxImage *arg1 = (wxImage *) 0 ;
15923 SwigValueWrapper<wxImage > result;
15924 void *argp1 = 0 ;
15925 int res1 = 0 ;
15926 PyObject *swig_obj[1] ;
15927
15928 if (!args) SWIG_fail;
15929 swig_obj[0] = args;
15930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15931 if (!SWIG_IsOK(res1)) {
15932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15933 }
15934 arg1 = reinterpret_cast< wxImage * >(argp1);
15935 {
15936 PyThreadState* __tstate = wxPyBeginAllowThreads();
15937 result = (arg1)->Copy();
15938 wxPyEndAllowThreads(__tstate);
15939 if (PyErr_Occurred()) SWIG_fail;
15940 }
15941 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15942 return resultobj;
15943 fail:
15944 return NULL;
15945 }
15946
15947
15948 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15949 PyObject *resultobj = 0;
15950 wxImage *arg1 = (wxImage *) 0 ;
15951 wxImage *arg2 = 0 ;
15952 int arg3 ;
15953 int arg4 ;
15954 void *argp1 = 0 ;
15955 int res1 = 0 ;
15956 void *argp2 = 0 ;
15957 int res2 = 0 ;
15958 int val3 ;
15959 int ecode3 = 0 ;
15960 int val4 ;
15961 int ecode4 = 0 ;
15962 PyObject * obj0 = 0 ;
15963 PyObject * obj1 = 0 ;
15964 PyObject * obj2 = 0 ;
15965 PyObject * obj3 = 0 ;
15966 char * kwnames[] = {
15967 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15968 };
15969
15970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15972 if (!SWIG_IsOK(res1)) {
15973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15974 }
15975 arg1 = reinterpret_cast< wxImage * >(argp1);
15976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15977 if (!SWIG_IsOK(res2)) {
15978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15979 }
15980 if (!argp2) {
15981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15982 }
15983 arg2 = reinterpret_cast< wxImage * >(argp2);
15984 ecode3 = SWIG_AsVal_int(obj2, &val3);
15985 if (!SWIG_IsOK(ecode3)) {
15986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15987 }
15988 arg3 = static_cast< int >(val3);
15989 ecode4 = SWIG_AsVal_int(obj3, &val4);
15990 if (!SWIG_IsOK(ecode4)) {
15991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15992 }
15993 arg4 = static_cast< int >(val4);
15994 {
15995 PyThreadState* __tstate = wxPyBeginAllowThreads();
15996 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15997 wxPyEndAllowThreads(__tstate);
15998 if (PyErr_Occurred()) SWIG_fail;
15999 }
16000 resultobj = SWIG_Py_Void();
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16008 PyObject *resultobj = 0;
16009 wxImage *arg1 = (wxImage *) 0 ;
16010 PyObject *result = 0 ;
16011 void *argp1 = 0 ;
16012 int res1 = 0 ;
16013 PyObject *swig_obj[1] ;
16014
16015 if (!args) SWIG_fail;
16016 swig_obj[0] = args;
16017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16018 if (!SWIG_IsOK(res1)) {
16019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16020 }
16021 arg1 = reinterpret_cast< wxImage * >(argp1);
16022 {
16023 PyThreadState* __tstate = wxPyBeginAllowThreads();
16024 result = (PyObject *)wxImage_GetData(arg1);
16025 wxPyEndAllowThreads(__tstate);
16026 if (PyErr_Occurred()) SWIG_fail;
16027 }
16028 resultobj = result;
16029 return resultobj;
16030 fail:
16031 return NULL;
16032 }
16033
16034
16035 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj = 0;
16037 wxImage *arg1 = (wxImage *) 0 ;
16038 buffer arg2 ;
16039 int arg3 ;
16040 void *argp1 = 0 ;
16041 int res1 = 0 ;
16042 Py_ssize_t temp2 ;
16043 PyObject * obj0 = 0 ;
16044 PyObject * obj1 = 0 ;
16045 char * kwnames[] = {
16046 (char *) "self",(char *) "data", NULL
16047 };
16048
16049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16051 if (!SWIG_IsOK(res1)) {
16052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16053 }
16054 arg1 = reinterpret_cast< wxImage * >(argp1);
16055 {
16056 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16057 arg3 = (int)temp2;
16058 }
16059 {
16060 PyThreadState* __tstate = wxPyBeginAllowThreads();
16061 wxImage_SetData(arg1,arg2,arg3);
16062 wxPyEndAllowThreads(__tstate);
16063 if (PyErr_Occurred()) SWIG_fail;
16064 }
16065 resultobj = SWIG_Py_Void();
16066 return resultobj;
16067 fail:
16068 return NULL;
16069 }
16070
16071
16072 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16073 PyObject *resultobj = 0;
16074 wxImage *arg1 = (wxImage *) 0 ;
16075 PyObject *result = 0 ;
16076 void *argp1 = 0 ;
16077 int res1 = 0 ;
16078 PyObject *swig_obj[1] ;
16079
16080 if (!args) SWIG_fail;
16081 swig_obj[0] = args;
16082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16083 if (!SWIG_IsOK(res1)) {
16084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16085 }
16086 arg1 = reinterpret_cast< wxImage * >(argp1);
16087 {
16088 PyThreadState* __tstate = wxPyBeginAllowThreads();
16089 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 resultobj = result;
16094 return resultobj;
16095 fail:
16096 return NULL;
16097 }
16098
16099
16100 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16101 PyObject *resultobj = 0;
16102 wxImage *arg1 = (wxImage *) 0 ;
16103 buffer arg2 ;
16104 int arg3 ;
16105 void *argp1 = 0 ;
16106 int res1 = 0 ;
16107 Py_ssize_t temp2 ;
16108 PyObject * obj0 = 0 ;
16109 PyObject * obj1 = 0 ;
16110 char * kwnames[] = {
16111 (char *) "self",(char *) "data", NULL
16112 };
16113
16114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16116 if (!SWIG_IsOK(res1)) {
16117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16118 }
16119 arg1 = reinterpret_cast< wxImage * >(argp1);
16120 {
16121 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16122 arg3 = (int)temp2;
16123 }
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 wxImage_SetDataBuffer(arg1,arg2,arg3);
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 resultobj = SWIG_Py_Void();
16131 return resultobj;
16132 fail:
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16138 PyObject *resultobj = 0;
16139 wxImage *arg1 = (wxImage *) 0 ;
16140 PyObject *result = 0 ;
16141 void *argp1 = 0 ;
16142 int res1 = 0 ;
16143 PyObject *swig_obj[1] ;
16144
16145 if (!args) SWIG_fail;
16146 swig_obj[0] = args;
16147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16150 }
16151 arg1 = reinterpret_cast< wxImage * >(argp1);
16152 {
16153 PyThreadState* __tstate = wxPyBeginAllowThreads();
16154 result = (PyObject *)wxImage_GetAlphaData(arg1);
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 resultobj = result;
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj = 0;
16167 wxImage *arg1 = (wxImage *) 0 ;
16168 buffer arg2 ;
16169 int arg3 ;
16170 void *argp1 = 0 ;
16171 int res1 = 0 ;
16172 Py_ssize_t temp2 ;
16173 PyObject * obj0 = 0 ;
16174 PyObject * obj1 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "self",(char *) "alpha", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16181 if (!SWIG_IsOK(res1)) {
16182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16183 }
16184 arg1 = reinterpret_cast< wxImage * >(argp1);
16185 {
16186 if (obj1 != Py_None) {
16187 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16188 arg3 = (int)temp2;
16189 }
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 wxImage_SetAlphaData(arg1,arg2,arg3);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_Py_Void();
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 PyObject *result = 0 ;
16208 void *argp1 = 0 ;
16209 int res1 = 0 ;
16210 PyObject *swig_obj[1] ;
16211
16212 if (!args) SWIG_fail;
16213 swig_obj[0] = args;
16214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16215 if (!SWIG_IsOK(res1)) {
16216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16217 }
16218 arg1 = reinterpret_cast< wxImage * >(argp1);
16219 {
16220 PyThreadState* __tstate = wxPyBeginAllowThreads();
16221 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16222 wxPyEndAllowThreads(__tstate);
16223 if (PyErr_Occurred()) SWIG_fail;
16224 }
16225 resultobj = result;
16226 return resultobj;
16227 fail:
16228 return NULL;
16229 }
16230
16231
16232 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16233 PyObject *resultobj = 0;
16234 wxImage *arg1 = (wxImage *) 0 ;
16235 buffer arg2 ;
16236 int arg3 ;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 Py_ssize_t temp2 ;
16240 PyObject * obj0 = 0 ;
16241 PyObject * obj1 = 0 ;
16242 char * kwnames[] = {
16243 (char *) "self",(char *) "alpha", NULL
16244 };
16245
16246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16248 if (!SWIG_IsOK(res1)) {
16249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16250 }
16251 arg1 = reinterpret_cast< wxImage * >(argp1);
16252 {
16253 if (obj1 != Py_None) {
16254 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16255 arg3 = (int)temp2;
16256 }
16257 }
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_Py_Void();
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 byte arg2 ;
16275 byte arg3 ;
16276 byte arg4 ;
16277 void *argp1 = 0 ;
16278 int res1 = 0 ;
16279 unsigned char val2 ;
16280 int ecode2 = 0 ;
16281 unsigned char val3 ;
16282 int ecode3 = 0 ;
16283 unsigned char val4 ;
16284 int ecode4 = 0 ;
16285 PyObject * obj0 = 0 ;
16286 PyObject * obj1 = 0 ;
16287 PyObject * obj2 = 0 ;
16288 PyObject * obj3 = 0 ;
16289 char * kwnames[] = {
16290 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16291 };
16292
16293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16297 }
16298 arg1 = reinterpret_cast< wxImage * >(argp1);
16299 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16300 if (!SWIG_IsOK(ecode2)) {
16301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16302 }
16303 arg2 = static_cast< byte >(val2);
16304 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16305 if (!SWIG_IsOK(ecode3)) {
16306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16307 }
16308 arg3 = static_cast< byte >(val3);
16309 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16310 if (!SWIG_IsOK(ecode4)) {
16311 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16312 }
16313 arg4 = static_cast< byte >(val4);
16314 {
16315 PyThreadState* __tstate = wxPyBeginAllowThreads();
16316 (arg1)->SetMaskColour(arg2,arg3,arg4);
16317 wxPyEndAllowThreads(__tstate);
16318 if (PyErr_Occurred()) SWIG_fail;
16319 }
16320 resultobj = SWIG_Py_Void();
16321 return resultobj;
16322 fail:
16323 return NULL;
16324 }
16325
16326
16327 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16328 PyObject *resultobj = 0;
16329 wxImage *arg1 = (wxImage *) 0 ;
16330 byte *arg2 = (byte *) 0 ;
16331 byte *arg3 = (byte *) 0 ;
16332 byte *arg4 = (byte *) 0 ;
16333 void *argp1 = 0 ;
16334 int res1 = 0 ;
16335 byte temp2 ;
16336 int res2 = SWIG_TMPOBJ ;
16337 byte temp3 ;
16338 int res3 = SWIG_TMPOBJ ;
16339 byte temp4 ;
16340 int res4 = SWIG_TMPOBJ ;
16341 PyObject *swig_obj[1] ;
16342
16343 arg2 = &temp2;
16344 arg3 = &temp3;
16345 arg4 = &temp4;
16346 if (!args) SWIG_fail;
16347 swig_obj[0] = args;
16348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16349 if (!SWIG_IsOK(res1)) {
16350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16351 }
16352 arg1 = reinterpret_cast< wxImage * >(argp1);
16353 {
16354 PyThreadState* __tstate = wxPyBeginAllowThreads();
16355 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16356 wxPyEndAllowThreads(__tstate);
16357 if (PyErr_Occurred()) SWIG_fail;
16358 }
16359 resultobj = SWIG_Py_Void();
16360 if (SWIG_IsTmpObj(res2)) {
16361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16362 } else {
16363 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16365 }
16366 if (SWIG_IsTmpObj(res3)) {
16367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16368 } else {
16369 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16371 }
16372 if (SWIG_IsTmpObj(res4)) {
16373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16374 } else {
16375 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16377 }
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16385 PyObject *resultobj = 0;
16386 wxImage *arg1 = (wxImage *) 0 ;
16387 byte result;
16388 void *argp1 = 0 ;
16389 int res1 = 0 ;
16390 PyObject *swig_obj[1] ;
16391
16392 if (!args) SWIG_fail;
16393 swig_obj[0] = args;
16394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16395 if (!SWIG_IsOK(res1)) {
16396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16397 }
16398 arg1 = reinterpret_cast< wxImage * >(argp1);
16399 {
16400 PyThreadState* __tstate = wxPyBeginAllowThreads();
16401 result = (byte)(arg1)->GetMaskRed();
16402 wxPyEndAllowThreads(__tstate);
16403 if (PyErr_Occurred()) SWIG_fail;
16404 }
16405 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16406 return resultobj;
16407 fail:
16408 return NULL;
16409 }
16410
16411
16412 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16413 PyObject *resultobj = 0;
16414 wxImage *arg1 = (wxImage *) 0 ;
16415 byte result;
16416 void *argp1 = 0 ;
16417 int res1 = 0 ;
16418 PyObject *swig_obj[1] ;
16419
16420 if (!args) SWIG_fail;
16421 swig_obj[0] = args;
16422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16423 if (!SWIG_IsOK(res1)) {
16424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16425 }
16426 arg1 = reinterpret_cast< wxImage * >(argp1);
16427 {
16428 PyThreadState* __tstate = wxPyBeginAllowThreads();
16429 result = (byte)(arg1)->GetMaskGreen();
16430 wxPyEndAllowThreads(__tstate);
16431 if (PyErr_Occurred()) SWIG_fail;
16432 }
16433 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16434 return resultobj;
16435 fail:
16436 return NULL;
16437 }
16438
16439
16440 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16441 PyObject *resultobj = 0;
16442 wxImage *arg1 = (wxImage *) 0 ;
16443 byte result;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 PyObject *swig_obj[1] ;
16447
16448 if (!args) SWIG_fail;
16449 swig_obj[0] = args;
16450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16453 }
16454 arg1 = reinterpret_cast< wxImage * >(argp1);
16455 {
16456 PyThreadState* __tstate = wxPyBeginAllowThreads();
16457 result = (byte)(arg1)->GetMaskBlue();
16458 wxPyEndAllowThreads(__tstate);
16459 if (PyErr_Occurred()) SWIG_fail;
16460 }
16461 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16462 return resultobj;
16463 fail:
16464 return NULL;
16465 }
16466
16467
16468 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16469 PyObject *resultobj = 0;
16470 wxImage *arg1 = (wxImage *) 0 ;
16471 bool arg2 = (bool) true ;
16472 void *argp1 = 0 ;
16473 int res1 = 0 ;
16474 bool val2 ;
16475 int ecode2 = 0 ;
16476 PyObject * obj0 = 0 ;
16477 PyObject * obj1 = 0 ;
16478 char * kwnames[] = {
16479 (char *) "self",(char *) "mask", NULL
16480 };
16481
16482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16484 if (!SWIG_IsOK(res1)) {
16485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16486 }
16487 arg1 = reinterpret_cast< wxImage * >(argp1);
16488 if (obj1) {
16489 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16490 if (!SWIG_IsOK(ecode2)) {
16491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16492 }
16493 arg2 = static_cast< bool >(val2);
16494 }
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 (arg1)->SetMask(arg2);
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 resultobj = SWIG_Py_Void();
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16509 PyObject *resultobj = 0;
16510 wxImage *arg1 = (wxImage *) 0 ;
16511 bool result;
16512 void *argp1 = 0 ;
16513 int res1 = 0 ;
16514 PyObject *swig_obj[1] ;
16515
16516 if (!args) SWIG_fail;
16517 swig_obj[0] = args;
16518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16519 if (!SWIG_IsOK(res1)) {
16520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16521 }
16522 arg1 = reinterpret_cast< wxImage * >(argp1);
16523 {
16524 PyThreadState* __tstate = wxPyBeginAllowThreads();
16525 result = (bool)(arg1)->HasMask();
16526 wxPyEndAllowThreads(__tstate);
16527 if (PyErr_Occurred()) SWIG_fail;
16528 }
16529 {
16530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16531 }
16532 return resultobj;
16533 fail:
16534 return NULL;
16535 }
16536
16537
16538 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16539 PyObject *resultobj = 0;
16540 wxImage *arg1 = (wxImage *) 0 ;
16541 double arg2 ;
16542 wxPoint *arg3 = 0 ;
16543 bool arg4 = (bool) true ;
16544 wxPoint *arg5 = (wxPoint *) NULL ;
16545 SwigValueWrapper<wxImage > result;
16546 void *argp1 = 0 ;
16547 int res1 = 0 ;
16548 double val2 ;
16549 int ecode2 = 0 ;
16550 wxPoint temp3 ;
16551 bool val4 ;
16552 int ecode4 = 0 ;
16553 void *argp5 = 0 ;
16554 int res5 = 0 ;
16555 PyObject * obj0 = 0 ;
16556 PyObject * obj1 = 0 ;
16557 PyObject * obj2 = 0 ;
16558 PyObject * obj3 = 0 ;
16559 PyObject * obj4 = 0 ;
16560 char * kwnames[] = {
16561 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16562 };
16563
16564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16566 if (!SWIG_IsOK(res1)) {
16567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16568 }
16569 arg1 = reinterpret_cast< wxImage * >(argp1);
16570 ecode2 = SWIG_AsVal_double(obj1, &val2);
16571 if (!SWIG_IsOK(ecode2)) {
16572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16573 }
16574 arg2 = static_cast< double >(val2);
16575 {
16576 arg3 = &temp3;
16577 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16578 }
16579 if (obj3) {
16580 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16581 if (!SWIG_IsOK(ecode4)) {
16582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16583 }
16584 arg4 = static_cast< bool >(val4);
16585 }
16586 if (obj4) {
16587 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16588 if (!SWIG_IsOK(res5)) {
16589 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16590 }
16591 arg5 = reinterpret_cast< wxPoint * >(argp5);
16592 }
16593 {
16594 PyThreadState* __tstate = wxPyBeginAllowThreads();
16595 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16596 wxPyEndAllowThreads(__tstate);
16597 if (PyErr_Occurred()) SWIG_fail;
16598 }
16599 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16600 return resultobj;
16601 fail:
16602 return NULL;
16603 }
16604
16605
16606 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16607 PyObject *resultobj = 0;
16608 wxImage *arg1 = (wxImage *) 0 ;
16609 bool arg2 = (bool) true ;
16610 SwigValueWrapper<wxImage > result;
16611 void *argp1 = 0 ;
16612 int res1 = 0 ;
16613 bool val2 ;
16614 int ecode2 = 0 ;
16615 PyObject * obj0 = 0 ;
16616 PyObject * obj1 = 0 ;
16617 char * kwnames[] = {
16618 (char *) "self",(char *) "clockwise", NULL
16619 };
16620
16621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16623 if (!SWIG_IsOK(res1)) {
16624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16625 }
16626 arg1 = reinterpret_cast< wxImage * >(argp1);
16627 if (obj1) {
16628 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16629 if (!SWIG_IsOK(ecode2)) {
16630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16631 }
16632 arg2 = static_cast< bool >(val2);
16633 }
16634 {
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = (arg1)->Rotate90(arg2);
16637 wxPyEndAllowThreads(__tstate);
16638 if (PyErr_Occurred()) SWIG_fail;
16639 }
16640 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16641 return resultobj;
16642 fail:
16643 return NULL;
16644 }
16645
16646
16647 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16648 PyObject *resultobj = 0;
16649 wxImage *arg1 = (wxImage *) 0 ;
16650 bool arg2 = (bool) true ;
16651 SwigValueWrapper<wxImage > result;
16652 void *argp1 = 0 ;
16653 int res1 = 0 ;
16654 bool val2 ;
16655 int ecode2 = 0 ;
16656 PyObject * obj0 = 0 ;
16657 PyObject * obj1 = 0 ;
16658 char * kwnames[] = {
16659 (char *) "self",(char *) "horizontally", NULL
16660 };
16661
16662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16664 if (!SWIG_IsOK(res1)) {
16665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16666 }
16667 arg1 = reinterpret_cast< wxImage * >(argp1);
16668 if (obj1) {
16669 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16670 if (!SWIG_IsOK(ecode2)) {
16671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16672 }
16673 arg2 = static_cast< bool >(val2);
16674 }
16675 {
16676 PyThreadState* __tstate = wxPyBeginAllowThreads();
16677 result = (arg1)->Mirror(arg2);
16678 wxPyEndAllowThreads(__tstate);
16679 if (PyErr_Occurred()) SWIG_fail;
16680 }
16681 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj = 0;
16690 wxImage *arg1 = (wxImage *) 0 ;
16691 byte arg2 ;
16692 byte arg3 ;
16693 byte arg4 ;
16694 byte arg5 ;
16695 byte arg6 ;
16696 byte arg7 ;
16697 void *argp1 = 0 ;
16698 int res1 = 0 ;
16699 unsigned char val2 ;
16700 int ecode2 = 0 ;
16701 unsigned char val3 ;
16702 int ecode3 = 0 ;
16703 unsigned char val4 ;
16704 int ecode4 = 0 ;
16705 unsigned char val5 ;
16706 int ecode5 = 0 ;
16707 unsigned char val6 ;
16708 int ecode6 = 0 ;
16709 unsigned char val7 ;
16710 int ecode7 = 0 ;
16711 PyObject * obj0 = 0 ;
16712 PyObject * obj1 = 0 ;
16713 PyObject * obj2 = 0 ;
16714 PyObject * obj3 = 0 ;
16715 PyObject * obj4 = 0 ;
16716 PyObject * obj5 = 0 ;
16717 PyObject * obj6 = 0 ;
16718 char * kwnames[] = {
16719 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16720 };
16721
16722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16724 if (!SWIG_IsOK(res1)) {
16725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16726 }
16727 arg1 = reinterpret_cast< wxImage * >(argp1);
16728 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16729 if (!SWIG_IsOK(ecode2)) {
16730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16731 }
16732 arg2 = static_cast< byte >(val2);
16733 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16734 if (!SWIG_IsOK(ecode3)) {
16735 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16736 }
16737 arg3 = static_cast< byte >(val3);
16738 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16739 if (!SWIG_IsOK(ecode4)) {
16740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16741 }
16742 arg4 = static_cast< byte >(val4);
16743 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16744 if (!SWIG_IsOK(ecode5)) {
16745 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16746 }
16747 arg5 = static_cast< byte >(val5);
16748 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16749 if (!SWIG_IsOK(ecode6)) {
16750 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16751 }
16752 arg6 = static_cast< byte >(val6);
16753 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16754 if (!SWIG_IsOK(ecode7)) {
16755 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16756 }
16757 arg7 = static_cast< byte >(val7);
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 resultobj = SWIG_Py_Void();
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj = 0;
16773 wxImage *arg1 = (wxImage *) 0 ;
16774 double arg2 = (double) 0.299 ;
16775 double arg3 = (double) 0.587 ;
16776 double arg4 = (double) 0.114 ;
16777 SwigValueWrapper<wxImage > result;
16778 void *argp1 = 0 ;
16779 int res1 = 0 ;
16780 double val2 ;
16781 int ecode2 = 0 ;
16782 double val3 ;
16783 int ecode3 = 0 ;
16784 double val4 ;
16785 int ecode4 = 0 ;
16786 PyObject * obj0 = 0 ;
16787 PyObject * obj1 = 0 ;
16788 PyObject * obj2 = 0 ;
16789 PyObject * obj3 = 0 ;
16790 char * kwnames[] = {
16791 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16792 };
16793
16794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16796 if (!SWIG_IsOK(res1)) {
16797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16798 }
16799 arg1 = reinterpret_cast< wxImage * >(argp1);
16800 if (obj1) {
16801 ecode2 = SWIG_AsVal_double(obj1, &val2);
16802 if (!SWIG_IsOK(ecode2)) {
16803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16804 }
16805 arg2 = static_cast< double >(val2);
16806 }
16807 if (obj2) {
16808 ecode3 = SWIG_AsVal_double(obj2, &val3);
16809 if (!SWIG_IsOK(ecode3)) {
16810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16811 }
16812 arg3 = static_cast< double >(val3);
16813 }
16814 if (obj3) {
16815 ecode4 = SWIG_AsVal_double(obj3, &val4);
16816 if (!SWIG_IsOK(ecode4)) {
16817 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16818 }
16819 arg4 = static_cast< double >(val4);
16820 }
16821 {
16822 PyThreadState* __tstate = wxPyBeginAllowThreads();
16823 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16828 return resultobj;
16829 fail:
16830 return NULL;
16831 }
16832
16833
16834 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16835 PyObject *resultobj = 0;
16836 wxImage *arg1 = (wxImage *) 0 ;
16837 byte arg2 ;
16838 byte arg3 ;
16839 byte arg4 ;
16840 SwigValueWrapper<wxImage > result;
16841 void *argp1 = 0 ;
16842 int res1 = 0 ;
16843 unsigned char val2 ;
16844 int ecode2 = 0 ;
16845 unsigned char val3 ;
16846 int ecode3 = 0 ;
16847 unsigned char val4 ;
16848 int ecode4 = 0 ;
16849 PyObject * obj0 = 0 ;
16850 PyObject * obj1 = 0 ;
16851 PyObject * obj2 = 0 ;
16852 PyObject * obj3 = 0 ;
16853 char * kwnames[] = {
16854 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16855 };
16856
16857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16859 if (!SWIG_IsOK(res1)) {
16860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16861 }
16862 arg1 = reinterpret_cast< wxImage * >(argp1);
16863 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16864 if (!SWIG_IsOK(ecode2)) {
16865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16866 }
16867 arg2 = static_cast< byte >(val2);
16868 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16869 if (!SWIG_IsOK(ecode3)) {
16870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16871 }
16872 arg3 = static_cast< byte >(val3);
16873 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16874 if (!SWIG_IsOK(ecode4)) {
16875 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16876 }
16877 arg4 = static_cast< byte >(val4);
16878 {
16879 PyThreadState* __tstate = wxPyBeginAllowThreads();
16880 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16881 wxPyEndAllowThreads(__tstate);
16882 if (PyErr_Occurred()) SWIG_fail;
16883 }
16884 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16892 PyObject *resultobj = 0;
16893 wxImage *arg1 = (wxImage *) 0 ;
16894 wxString *arg2 = 0 ;
16895 wxString *arg3 = 0 ;
16896 void *argp1 = 0 ;
16897 int res1 = 0 ;
16898 bool temp2 = false ;
16899 bool temp3 = false ;
16900 PyObject * obj0 = 0 ;
16901 PyObject * obj1 = 0 ;
16902 PyObject * obj2 = 0 ;
16903 char * kwnames[] = {
16904 (char *) "self",(char *) "name",(char *) "value", NULL
16905 };
16906
16907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16909 if (!SWIG_IsOK(res1)) {
16910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16911 }
16912 arg1 = reinterpret_cast< wxImage * >(argp1);
16913 {
16914 arg2 = wxString_in_helper(obj1);
16915 if (arg2 == NULL) SWIG_fail;
16916 temp2 = true;
16917 }
16918 {
16919 arg3 = wxString_in_helper(obj2);
16920 if (arg3 == NULL) SWIG_fail;
16921 temp3 = true;
16922 }
16923 {
16924 PyThreadState* __tstate = wxPyBeginAllowThreads();
16925 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16926 wxPyEndAllowThreads(__tstate);
16927 if (PyErr_Occurred()) SWIG_fail;
16928 }
16929 resultobj = SWIG_Py_Void();
16930 {
16931 if (temp2)
16932 delete arg2;
16933 }
16934 {
16935 if (temp3)
16936 delete arg3;
16937 }
16938 return resultobj;
16939 fail:
16940 {
16941 if (temp2)
16942 delete arg2;
16943 }
16944 {
16945 if (temp3)
16946 delete arg3;
16947 }
16948 return NULL;
16949 }
16950
16951
16952 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj = 0;
16954 wxImage *arg1 = (wxImage *) 0 ;
16955 wxString *arg2 = 0 ;
16956 int arg3 ;
16957 void *argp1 = 0 ;
16958 int res1 = 0 ;
16959 bool temp2 = false ;
16960 int val3 ;
16961 int ecode3 = 0 ;
16962 PyObject * obj0 = 0 ;
16963 PyObject * obj1 = 0 ;
16964 PyObject * obj2 = 0 ;
16965 char * kwnames[] = {
16966 (char *) "self",(char *) "name",(char *) "value", NULL
16967 };
16968
16969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16971 if (!SWIG_IsOK(res1)) {
16972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16973 }
16974 arg1 = reinterpret_cast< wxImage * >(argp1);
16975 {
16976 arg2 = wxString_in_helper(obj1);
16977 if (arg2 == NULL) SWIG_fail;
16978 temp2 = true;
16979 }
16980 ecode3 = SWIG_AsVal_int(obj2, &val3);
16981 if (!SWIG_IsOK(ecode3)) {
16982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16983 }
16984 arg3 = static_cast< int >(val3);
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 (arg1)->SetOption((wxString const &)*arg2,arg3);
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 resultobj = SWIG_Py_Void();
16992 {
16993 if (temp2)
16994 delete arg2;
16995 }
16996 return resultobj;
16997 fail:
16998 {
16999 if (temp2)
17000 delete arg2;
17001 }
17002 return NULL;
17003 }
17004
17005
17006 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17007 PyObject *resultobj = 0;
17008 wxImage *arg1 = (wxImage *) 0 ;
17009 wxString *arg2 = 0 ;
17010 wxString result;
17011 void *argp1 = 0 ;
17012 int res1 = 0 ;
17013 bool temp2 = false ;
17014 PyObject * obj0 = 0 ;
17015 PyObject * obj1 = 0 ;
17016 char * kwnames[] = {
17017 (char *) "self",(char *) "name", NULL
17018 };
17019
17020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17022 if (!SWIG_IsOK(res1)) {
17023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17024 }
17025 arg1 = reinterpret_cast< wxImage * >(argp1);
17026 {
17027 arg2 = wxString_in_helper(obj1);
17028 if (arg2 == NULL) SWIG_fail;
17029 temp2 = true;
17030 }
17031 {
17032 PyThreadState* __tstate = wxPyBeginAllowThreads();
17033 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17034 wxPyEndAllowThreads(__tstate);
17035 if (PyErr_Occurred()) SWIG_fail;
17036 }
17037 {
17038 #if wxUSE_UNICODE
17039 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17040 #else
17041 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17042 #endif
17043 }
17044 {
17045 if (temp2)
17046 delete arg2;
17047 }
17048 return resultobj;
17049 fail:
17050 {
17051 if (temp2)
17052 delete arg2;
17053 }
17054 return NULL;
17055 }
17056
17057
17058 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17059 PyObject *resultobj = 0;
17060 wxImage *arg1 = (wxImage *) 0 ;
17061 wxString *arg2 = 0 ;
17062 int result;
17063 void *argp1 = 0 ;
17064 int res1 = 0 ;
17065 bool temp2 = false ;
17066 PyObject * obj0 = 0 ;
17067 PyObject * obj1 = 0 ;
17068 char * kwnames[] = {
17069 (char *) "self",(char *) "name", NULL
17070 };
17071
17072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17074 if (!SWIG_IsOK(res1)) {
17075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17076 }
17077 arg1 = reinterpret_cast< wxImage * >(argp1);
17078 {
17079 arg2 = wxString_in_helper(obj1);
17080 if (arg2 == NULL) SWIG_fail;
17081 temp2 = true;
17082 }
17083 {
17084 PyThreadState* __tstate = wxPyBeginAllowThreads();
17085 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17086 wxPyEndAllowThreads(__tstate);
17087 if (PyErr_Occurred()) SWIG_fail;
17088 }
17089 resultobj = SWIG_From_int(static_cast< int >(result));
17090 {
17091 if (temp2)
17092 delete arg2;
17093 }
17094 return resultobj;
17095 fail:
17096 {
17097 if (temp2)
17098 delete arg2;
17099 }
17100 return NULL;
17101 }
17102
17103
17104 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17105 PyObject *resultobj = 0;
17106 wxImage *arg1 = (wxImage *) 0 ;
17107 wxString *arg2 = 0 ;
17108 bool result;
17109 void *argp1 = 0 ;
17110 int res1 = 0 ;
17111 bool temp2 = false ;
17112 PyObject * obj0 = 0 ;
17113 PyObject * obj1 = 0 ;
17114 char * kwnames[] = {
17115 (char *) "self",(char *) "name", NULL
17116 };
17117
17118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17120 if (!SWIG_IsOK(res1)) {
17121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17122 }
17123 arg1 = reinterpret_cast< wxImage * >(argp1);
17124 {
17125 arg2 = wxString_in_helper(obj1);
17126 if (arg2 == NULL) SWIG_fail;
17127 temp2 = true;
17128 }
17129 {
17130 PyThreadState* __tstate = wxPyBeginAllowThreads();
17131 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17132 wxPyEndAllowThreads(__tstate);
17133 if (PyErr_Occurred()) SWIG_fail;
17134 }
17135 {
17136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17137 }
17138 {
17139 if (temp2)
17140 delete arg2;
17141 }
17142 return resultobj;
17143 fail:
17144 {
17145 if (temp2)
17146 delete arg2;
17147 }
17148 return NULL;
17149 }
17150
17151
17152 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17153 PyObject *resultobj = 0;
17154 wxImage *arg1 = (wxImage *) 0 ;
17155 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17156 unsigned long result;
17157 void *argp1 = 0 ;
17158 int res1 = 0 ;
17159 unsigned long val2 ;
17160 int ecode2 = 0 ;
17161 PyObject * obj0 = 0 ;
17162 PyObject * obj1 = 0 ;
17163 char * kwnames[] = {
17164 (char *) "self",(char *) "stopafter", NULL
17165 };
17166
17167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17169 if (!SWIG_IsOK(res1)) {
17170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17171 }
17172 arg1 = reinterpret_cast< wxImage * >(argp1);
17173 if (obj1) {
17174 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17175 if (!SWIG_IsOK(ecode2)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17177 }
17178 arg2 = static_cast< unsigned long >(val2);
17179 }
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (unsigned long)(arg1)->CountColours(arg2);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj = 0;
17195 wxImage *arg1 = (wxImage *) 0 ;
17196 wxImageHistogram *arg2 = 0 ;
17197 unsigned long result;
17198 void *argp1 = 0 ;
17199 int res1 = 0 ;
17200 void *argp2 = 0 ;
17201 int res2 = 0 ;
17202 PyObject * obj0 = 0 ;
17203 PyObject * obj1 = 0 ;
17204 char * kwnames[] = {
17205 (char *) "self",(char *) "h", NULL
17206 };
17207
17208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17210 if (!SWIG_IsOK(res1)) {
17211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17212 }
17213 arg1 = reinterpret_cast< wxImage * >(argp1);
17214 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17215 if (!SWIG_IsOK(res2)) {
17216 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17217 }
17218 if (!argp2) {
17219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17220 }
17221 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17225 wxPyEndAllowThreads(__tstate);
17226 if (PyErr_Occurred()) SWIG_fail;
17227 }
17228 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17229 return resultobj;
17230 fail:
17231 return NULL;
17232 }
17233
17234
17235 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17236 PyObject *resultobj = 0;
17237 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17238 void *argp1 = 0 ;
17239 int res1 = 0 ;
17240 PyObject * obj0 = 0 ;
17241 char * kwnames[] = {
17242 (char *) "handler", NULL
17243 };
17244
17245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17247 if (!SWIG_IsOK(res1)) {
17248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17249 }
17250 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17251 {
17252 PyThreadState* __tstate = wxPyBeginAllowThreads();
17253 wxImage::AddHandler(arg1);
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 resultobj = SWIG_Py_Void();
17258 return resultobj;
17259 fail:
17260 return NULL;
17261 }
17262
17263
17264 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17265 PyObject *resultobj = 0;
17266 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17267 void *argp1 = 0 ;
17268 int res1 = 0 ;
17269 PyObject * obj0 = 0 ;
17270 char * kwnames[] = {
17271 (char *) "handler", NULL
17272 };
17273
17274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17276 if (!SWIG_IsOK(res1)) {
17277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17278 }
17279 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17280 {
17281 PyThreadState* __tstate = wxPyBeginAllowThreads();
17282 wxImage::InsertHandler(arg1);
17283 wxPyEndAllowThreads(__tstate);
17284 if (PyErr_Occurred()) SWIG_fail;
17285 }
17286 resultobj = SWIG_Py_Void();
17287 return resultobj;
17288 fail:
17289 return NULL;
17290 }
17291
17292
17293 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17294 PyObject *resultobj = 0;
17295 wxString *arg1 = 0 ;
17296 bool result;
17297 bool temp1 = false ;
17298 PyObject * obj0 = 0 ;
17299 char * kwnames[] = {
17300 (char *) "name", NULL
17301 };
17302
17303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17304 {
17305 arg1 = wxString_in_helper(obj0);
17306 if (arg1 == NULL) SWIG_fail;
17307 temp1 = true;
17308 }
17309 {
17310 PyThreadState* __tstate = wxPyBeginAllowThreads();
17311 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17312 wxPyEndAllowThreads(__tstate);
17313 if (PyErr_Occurred()) SWIG_fail;
17314 }
17315 {
17316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17317 }
17318 {
17319 if (temp1)
17320 delete arg1;
17321 }
17322 return resultobj;
17323 fail:
17324 {
17325 if (temp1)
17326 delete arg1;
17327 }
17328 return NULL;
17329 }
17330
17331
17332 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 PyObject *resultobj = 0;
17334 PyObject *result = 0 ;
17335
17336 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17337 {
17338 PyThreadState* __tstate = wxPyBeginAllowThreads();
17339 result = (PyObject *)wxImage_GetHandlers();
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 resultobj = result;
17344 return resultobj;
17345 fail:
17346 return NULL;
17347 }
17348
17349
17350 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 PyObject *resultobj = 0;
17352 wxString result;
17353
17354 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17355 {
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = wxImage::GetImageExtWildcard();
17358 wxPyEndAllowThreads(__tstate);
17359 if (PyErr_Occurred()) SWIG_fail;
17360 }
17361 {
17362 #if wxUSE_UNICODE
17363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17364 #else
17365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17366 #endif
17367 }
17368 return resultobj;
17369 fail:
17370 return NULL;
17371 }
17372
17373
17374 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17375 PyObject *resultobj = 0;
17376 wxImage *arg1 = (wxImage *) 0 ;
17377 int arg2 = (int) -1 ;
17378 wxBitmap result;
17379 void *argp1 = 0 ;
17380 int res1 = 0 ;
17381 int val2 ;
17382 int ecode2 = 0 ;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 char * kwnames[] = {
17386 (char *) "self",(char *) "depth", NULL
17387 };
17388
17389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17391 if (!SWIG_IsOK(res1)) {
17392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17393 }
17394 arg1 = reinterpret_cast< wxImage * >(argp1);
17395 if (obj1) {
17396 ecode2 = SWIG_AsVal_int(obj1, &val2);
17397 if (!SWIG_IsOK(ecode2)) {
17398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17399 }
17400 arg2 = static_cast< int >(val2);
17401 }
17402 {
17403 if (!wxPyCheckForApp()) SWIG_fail;
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 result = wxImage_ConvertToBitmap(arg1,arg2);
17406 wxPyEndAllowThreads(__tstate);
17407 if (PyErr_Occurred()) SWIG_fail;
17408 }
17409 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17410 return resultobj;
17411 fail:
17412 return NULL;
17413 }
17414
17415
17416 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17417 PyObject *resultobj = 0;
17418 wxImage *arg1 = (wxImage *) 0 ;
17419 byte arg2 ;
17420 byte arg3 ;
17421 byte arg4 ;
17422 wxBitmap result;
17423 void *argp1 = 0 ;
17424 int res1 = 0 ;
17425 unsigned char val2 ;
17426 int ecode2 = 0 ;
17427 unsigned char val3 ;
17428 int ecode3 = 0 ;
17429 unsigned char val4 ;
17430 int ecode4 = 0 ;
17431 PyObject * obj0 = 0 ;
17432 PyObject * obj1 = 0 ;
17433 PyObject * obj2 = 0 ;
17434 PyObject * obj3 = 0 ;
17435 char * kwnames[] = {
17436 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17437 };
17438
17439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17441 if (!SWIG_IsOK(res1)) {
17442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17443 }
17444 arg1 = reinterpret_cast< wxImage * >(argp1);
17445 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17446 if (!SWIG_IsOK(ecode2)) {
17447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17448 }
17449 arg2 = static_cast< byte >(val2);
17450 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17451 if (!SWIG_IsOK(ecode3)) {
17452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17453 }
17454 arg3 = static_cast< byte >(val3);
17455 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17456 if (!SWIG_IsOK(ecode4)) {
17457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17458 }
17459 arg4 = static_cast< byte >(val4);
17460 {
17461 if (!wxPyCheckForApp()) SWIG_fail;
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17475 PyObject *resultobj = 0;
17476 wxImage *arg1 = (wxImage *) 0 ;
17477 double arg2 ;
17478 void *argp1 = 0 ;
17479 int res1 = 0 ;
17480 double val2 ;
17481 int ecode2 = 0 ;
17482 PyObject * obj0 = 0 ;
17483 PyObject * obj1 = 0 ;
17484 char * kwnames[] = {
17485 (char *) "self",(char *) "angle", NULL
17486 };
17487
17488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17490 if (!SWIG_IsOK(res1)) {
17491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17492 }
17493 arg1 = reinterpret_cast< wxImage * >(argp1);
17494 ecode2 = SWIG_AsVal_double(obj1, &val2);
17495 if (!SWIG_IsOK(ecode2)) {
17496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17497 }
17498 arg2 = static_cast< double >(val2);
17499 {
17500 PyThreadState* __tstate = wxPyBeginAllowThreads();
17501 (arg1)->RotateHue(arg2);
17502 wxPyEndAllowThreads(__tstate);
17503 if (PyErr_Occurred()) SWIG_fail;
17504 }
17505 resultobj = SWIG_Py_Void();
17506 return resultobj;
17507 fail:
17508 return NULL;
17509 }
17510
17511
17512 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17513 PyObject *resultobj = 0;
17514 wxImage_RGBValue arg1 ;
17515 wxImage_HSVValue result;
17516 void *argp1 ;
17517 int res1 = 0 ;
17518 PyObject * obj0 = 0 ;
17519 char * kwnames[] = {
17520 (char *) "rgb", NULL
17521 };
17522
17523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17524 {
17525 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17526 if (!SWIG_IsOK(res1)) {
17527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17528 }
17529 if (!argp1) {
17530 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17531 } else {
17532 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17533 arg1 = *temp;
17534 if (SWIG_IsNewObj(res1)) delete temp;
17535 }
17536 }
17537 {
17538 PyThreadState* __tstate = wxPyBeginAllowThreads();
17539 result = wxImage::RGBtoHSV(arg1);
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17551 PyObject *resultobj = 0;
17552 wxImage_HSVValue arg1 ;
17553 wxImage_RGBValue result;
17554 void *argp1 ;
17555 int res1 = 0 ;
17556 PyObject * obj0 = 0 ;
17557 char * kwnames[] = {
17558 (char *) "hsv", NULL
17559 };
17560
17561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17562 {
17563 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17564 if (!SWIG_IsOK(res1)) {
17565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17566 }
17567 if (!argp1) {
17568 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17569 } else {
17570 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17571 arg1 = *temp;
17572 if (SWIG_IsNewObj(res1)) delete temp;
17573 }
17574 }
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = wxImage::HSVtoRGB(arg1);
17578 wxPyEndAllowThreads(__tstate);
17579 if (PyErr_Occurred()) SWIG_fail;
17580 }
17581 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17582 return resultobj;
17583 fail:
17584 return NULL;
17585 }
17586
17587
17588 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17589 PyObject *obj;
17590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17591 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17592 return SWIG_Py_Void();
17593 }
17594
17595 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17596 return SWIG_Python_InitShadowInstance(args);
17597 }
17598
17599 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17600 PyObject *resultobj = 0;
17601 int arg1 ;
17602 int arg2 ;
17603 buffer arg3 ;
17604 int arg4 ;
17605 buffer arg5 = (buffer) NULL ;
17606 int arg6 = (int) 0 ;
17607 wxImage *result = 0 ;
17608 int val1 ;
17609 int ecode1 = 0 ;
17610 int val2 ;
17611 int ecode2 = 0 ;
17612 Py_ssize_t temp3 ;
17613 Py_ssize_t temp5 ;
17614 PyObject * obj0 = 0 ;
17615 PyObject * obj1 = 0 ;
17616 PyObject * obj2 = 0 ;
17617 PyObject * obj3 = 0 ;
17618 char * kwnames[] = {
17619 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17620 };
17621
17622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17623 ecode1 = SWIG_AsVal_int(obj0, &val1);
17624 if (!SWIG_IsOK(ecode1)) {
17625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17626 }
17627 arg1 = static_cast< int >(val1);
17628 ecode2 = SWIG_AsVal_int(obj1, &val2);
17629 if (!SWIG_IsOK(ecode2)) {
17630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17631 }
17632 arg2 = static_cast< int >(val2);
17633 {
17634 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17635 arg4 = (int)temp3;
17636 }
17637 if (obj3) {
17638 {
17639 if (obj3 != Py_None) {
17640 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17641 arg6 = (int)temp5;
17642 }
17643 }
17644 }
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 {
17652 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17653 }
17654 return resultobj;
17655 fail:
17656 return NULL;
17657 }
17658
17659
17660 SWIGINTERN int NullImage_set(PyObject *) {
17661 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17662 return 1;
17663 }
17664
17665
17666 SWIGINTERN PyObject *NullImage_get(void) {
17667 PyObject *pyobj = 0;
17668
17669 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17670 return pyobj;
17671 }
17672
17673
17674 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17675 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17676 return 1;
17677 }
17678
17679
17680 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17681 PyObject *pyobj = 0;
17682
17683 {
17684 #if wxUSE_UNICODE
17685 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17686 #else
17687 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17688 #endif
17689 }
17690 return pyobj;
17691 }
17692
17693
17694 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17695 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17696 return 1;
17697 }
17698
17699
17700 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17701 PyObject *pyobj = 0;
17702
17703 {
17704 #if wxUSE_UNICODE
17705 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17706 #else
17707 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17708 #endif
17709 }
17710 return pyobj;
17711 }
17712
17713
17714 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17715 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17716 return 1;
17717 }
17718
17719
17720 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17721 PyObject *pyobj = 0;
17722
17723 {
17724 #if wxUSE_UNICODE
17725 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17726 #else
17727 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17728 #endif
17729 }
17730 return pyobj;
17731 }
17732
17733
17734 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17735 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17736 return 1;
17737 }
17738
17739
17740 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17741 PyObject *pyobj = 0;
17742
17743 {
17744 #if wxUSE_UNICODE
17745 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17746 #else
17747 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17748 #endif
17749 }
17750 return pyobj;
17751 }
17752
17753
17754 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17755 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17756 return 1;
17757 }
17758
17759
17760 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17761 PyObject *pyobj = 0;
17762
17763 {
17764 #if wxUSE_UNICODE
17765 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17766 #else
17767 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17768 #endif
17769 }
17770 return pyobj;
17771 }
17772
17773
17774 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17775 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17776 return 1;
17777 }
17778
17779
17780 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17781 PyObject *pyobj = 0;
17782
17783 {
17784 #if wxUSE_UNICODE
17785 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17786 #else
17787 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17788 #endif
17789 }
17790 return pyobj;
17791 }
17792
17793
17794 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17795 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17796 return 1;
17797 }
17798
17799
17800 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17801 PyObject *pyobj = 0;
17802
17803 {
17804 #if wxUSE_UNICODE
17805 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17806 #else
17807 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17808 #endif
17809 }
17810 return pyobj;
17811 }
17812
17813
17814 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17815 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17816 return 1;
17817 }
17818
17819
17820 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17821 PyObject *pyobj = 0;
17822
17823 {
17824 #if wxUSE_UNICODE
17825 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17826 #else
17827 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17828 #endif
17829 }
17830 return pyobj;
17831 }
17832
17833
17834 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17835 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17836 return 1;
17837 }
17838
17839
17840 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17841 PyObject *pyobj = 0;
17842
17843 {
17844 #if wxUSE_UNICODE
17845 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17846 #else
17847 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17848 #endif
17849 }
17850 return pyobj;
17851 }
17852
17853
17854 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17855 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17856 return 1;
17857 }
17858
17859
17860 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17861 PyObject *pyobj = 0;
17862
17863 {
17864 #if wxUSE_UNICODE
17865 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17866 #else
17867 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17868 #endif
17869 }
17870 return pyobj;
17871 }
17872
17873
17874 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17875 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17876 return 1;
17877 }
17878
17879
17880 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17881 PyObject *pyobj = 0;
17882
17883 {
17884 #if wxUSE_UNICODE
17885 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17886 #else
17887 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17888 #endif
17889 }
17890 return pyobj;
17891 }
17892
17893
17894 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17895 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17896 return 1;
17897 }
17898
17899
17900 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17901 PyObject *pyobj = 0;
17902
17903 {
17904 #if wxUSE_UNICODE
17905 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17906 #else
17907 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17908 #endif
17909 }
17910 return pyobj;
17911 }
17912
17913
17914 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17915 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17916 return 1;
17917 }
17918
17919
17920 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17921 PyObject *pyobj = 0;
17922
17923 {
17924 #if wxUSE_UNICODE
17925 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17926 #else
17927 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17928 #endif
17929 }
17930 return pyobj;
17931 }
17932
17933
17934 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17935 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17936 return 1;
17937 }
17938
17939
17940 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17941 PyObject *pyobj = 0;
17942
17943 {
17944 #if wxUSE_UNICODE
17945 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17946 #else
17947 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17948 #endif
17949 }
17950 return pyobj;
17951 }
17952
17953
17954 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17955 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17956 return 1;
17957 }
17958
17959
17960 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17961 PyObject *pyobj = 0;
17962
17963 {
17964 #if wxUSE_UNICODE
17965 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17966 #else
17967 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17968 #endif
17969 }
17970 return pyobj;
17971 }
17972
17973
17974 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17975 PyObject *resultobj = 0;
17976 wxBMPHandler *result = 0 ;
17977
17978 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17979 {
17980 PyThreadState* __tstate = wxPyBeginAllowThreads();
17981 result = (wxBMPHandler *)new wxBMPHandler();
17982 wxPyEndAllowThreads(__tstate);
17983 if (PyErr_Occurred()) SWIG_fail;
17984 }
17985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17986 return resultobj;
17987 fail:
17988 return NULL;
17989 }
17990
17991
17992 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17993 PyObject *obj;
17994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17995 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17996 return SWIG_Py_Void();
17997 }
17998
17999 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18000 return SWIG_Python_InitShadowInstance(args);
18001 }
18002
18003 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18004 PyObject *resultobj = 0;
18005 wxICOHandler *result = 0 ;
18006
18007 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 result = (wxICOHandler *)new wxICOHandler();
18011 wxPyEndAllowThreads(__tstate);
18012 if (PyErr_Occurred()) SWIG_fail;
18013 }
18014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18015 return resultobj;
18016 fail:
18017 return NULL;
18018 }
18019
18020
18021 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18022 PyObject *obj;
18023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18024 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18025 return SWIG_Py_Void();
18026 }
18027
18028 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18029 return SWIG_Python_InitShadowInstance(args);
18030 }
18031
18032 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18033 PyObject *resultobj = 0;
18034 wxCURHandler *result = 0 ;
18035
18036 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18037 {
18038 PyThreadState* __tstate = wxPyBeginAllowThreads();
18039 result = (wxCURHandler *)new wxCURHandler();
18040 wxPyEndAllowThreads(__tstate);
18041 if (PyErr_Occurred()) SWIG_fail;
18042 }
18043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18044 return resultobj;
18045 fail:
18046 return NULL;
18047 }
18048
18049
18050 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18051 PyObject *obj;
18052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18053 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18054 return SWIG_Py_Void();
18055 }
18056
18057 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18058 return SWIG_Python_InitShadowInstance(args);
18059 }
18060
18061 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18062 PyObject *resultobj = 0;
18063 wxANIHandler *result = 0 ;
18064
18065 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 result = (wxANIHandler *)new wxANIHandler();
18069 wxPyEndAllowThreads(__tstate);
18070 if (PyErr_Occurred()) SWIG_fail;
18071 }
18072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18073 return resultobj;
18074 fail:
18075 return NULL;
18076 }
18077
18078
18079 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 PyObject *obj;
18081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18082 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18083 return SWIG_Py_Void();
18084 }
18085
18086 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 return SWIG_Python_InitShadowInstance(args);
18088 }
18089
18090 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18091 PyObject *resultobj = 0;
18092 wxPNGHandler *result = 0 ;
18093
18094 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18095 {
18096 PyThreadState* __tstate = wxPyBeginAllowThreads();
18097 result = (wxPNGHandler *)new wxPNGHandler();
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18109 PyObject *obj;
18110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18111 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18112 return SWIG_Py_Void();
18113 }
18114
18115 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18116 return SWIG_Python_InitShadowInstance(args);
18117 }
18118
18119 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18120 PyObject *resultobj = 0;
18121 wxGIFHandler *result = 0 ;
18122
18123 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18124 {
18125 PyThreadState* __tstate = wxPyBeginAllowThreads();
18126 result = (wxGIFHandler *)new wxGIFHandler();
18127 wxPyEndAllowThreads(__tstate);
18128 if (PyErr_Occurred()) SWIG_fail;
18129 }
18130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18138 PyObject *obj;
18139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18140 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18141 return SWIG_Py_Void();
18142 }
18143
18144 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18145 return SWIG_Python_InitShadowInstance(args);
18146 }
18147
18148 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18149 PyObject *resultobj = 0;
18150 wxPCXHandler *result = 0 ;
18151
18152 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18153 {
18154 PyThreadState* __tstate = wxPyBeginAllowThreads();
18155 result = (wxPCXHandler *)new wxPCXHandler();
18156 wxPyEndAllowThreads(__tstate);
18157 if (PyErr_Occurred()) SWIG_fail;
18158 }
18159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18160 return resultobj;
18161 fail:
18162 return NULL;
18163 }
18164
18165
18166 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18167 PyObject *obj;
18168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18169 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18170 return SWIG_Py_Void();
18171 }
18172
18173 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18174 return SWIG_Python_InitShadowInstance(args);
18175 }
18176
18177 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18178 PyObject *resultobj = 0;
18179 wxJPEGHandler *result = 0 ;
18180
18181 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 result = (wxJPEGHandler *)new wxJPEGHandler();
18185 wxPyEndAllowThreads(__tstate);
18186 if (PyErr_Occurred()) SWIG_fail;
18187 }
18188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18189 return resultobj;
18190 fail:
18191 return NULL;
18192 }
18193
18194
18195 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18196 PyObject *obj;
18197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18198 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18199 return SWIG_Py_Void();
18200 }
18201
18202 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18203 return SWIG_Python_InitShadowInstance(args);
18204 }
18205
18206 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18207 PyObject *resultobj = 0;
18208 wxPNMHandler *result = 0 ;
18209
18210 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18211 {
18212 PyThreadState* __tstate = wxPyBeginAllowThreads();
18213 result = (wxPNMHandler *)new wxPNMHandler();
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18218 return resultobj;
18219 fail:
18220 return NULL;
18221 }
18222
18223
18224 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18225 PyObject *obj;
18226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18227 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18228 return SWIG_Py_Void();
18229 }
18230
18231 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18232 return SWIG_Python_InitShadowInstance(args);
18233 }
18234
18235 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18236 PyObject *resultobj = 0;
18237 wxXPMHandler *result = 0 ;
18238
18239 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18240 {
18241 PyThreadState* __tstate = wxPyBeginAllowThreads();
18242 result = (wxXPMHandler *)new wxXPMHandler();
18243 wxPyEndAllowThreads(__tstate);
18244 if (PyErr_Occurred()) SWIG_fail;
18245 }
18246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18247 return resultobj;
18248 fail:
18249 return NULL;
18250 }
18251
18252
18253 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18254 PyObject *obj;
18255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18256 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18257 return SWIG_Py_Void();
18258 }
18259
18260 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18261 return SWIG_Python_InitShadowInstance(args);
18262 }
18263
18264 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18265 PyObject *resultobj = 0;
18266 wxTIFFHandler *result = 0 ;
18267
18268 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 result = (wxTIFFHandler *)new wxTIFFHandler();
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 PyObject *obj;
18284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18285 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18286 return SWIG_Py_Void();
18287 }
18288
18289 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18290 return SWIG_Python_InitShadowInstance(args);
18291 }
18292
18293 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj = 0;
18295 wxImage *arg1 = 0 ;
18296 wxImage *arg2 = 0 ;
18297 int arg3 = (int) 236 ;
18298 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18299 bool result;
18300 void *argp1 = 0 ;
18301 int res1 = 0 ;
18302 void *argp2 = 0 ;
18303 int res2 = 0 ;
18304 int val3 ;
18305 int ecode3 = 0 ;
18306 int val4 ;
18307 int ecode4 = 0 ;
18308 PyObject * obj0 = 0 ;
18309 PyObject * obj1 = 0 ;
18310 PyObject * obj2 = 0 ;
18311 PyObject * obj3 = 0 ;
18312 char * kwnames[] = {
18313 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18314 };
18315
18316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18317 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18318 if (!SWIG_IsOK(res1)) {
18319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18320 }
18321 if (!argp1) {
18322 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18323 }
18324 arg1 = reinterpret_cast< wxImage * >(argp1);
18325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18326 if (!SWIG_IsOK(res2)) {
18327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18328 }
18329 if (!argp2) {
18330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18331 }
18332 arg2 = reinterpret_cast< wxImage * >(argp2);
18333 if (obj2) {
18334 ecode3 = SWIG_AsVal_int(obj2, &val3);
18335 if (!SWIG_IsOK(ecode3)) {
18336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18337 }
18338 arg3 = static_cast< int >(val3);
18339 }
18340 if (obj3) {
18341 ecode4 = SWIG_AsVal_int(obj3, &val4);
18342 if (!SWIG_IsOK(ecode4)) {
18343 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18344 }
18345 arg4 = static_cast< int >(val4);
18346 }
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 {
18354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18355 }
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18363 PyObject *obj;
18364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18365 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18366 return SWIG_Py_Void();
18367 }
18368
18369 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18370 PyObject *resultobj = 0;
18371 wxEvtHandler *result = 0 ;
18372
18373 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (wxEvtHandler *)new wxEvtHandler();
18377 wxPyEndAllowThreads(__tstate);
18378 if (PyErr_Occurred()) SWIG_fail;
18379 }
18380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18381 return resultobj;
18382 fail:
18383 return NULL;
18384 }
18385
18386
18387 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18388 PyObject *resultobj = 0;
18389 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18390 wxEvtHandler *result = 0 ;
18391 void *argp1 = 0 ;
18392 int res1 = 0 ;
18393 PyObject *swig_obj[1] ;
18394
18395 if (!args) SWIG_fail;
18396 swig_obj[0] = args;
18397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18398 if (!SWIG_IsOK(res1)) {
18399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18400 }
18401 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18402 {
18403 PyThreadState* __tstate = wxPyBeginAllowThreads();
18404 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18405 wxPyEndAllowThreads(__tstate);
18406 if (PyErr_Occurred()) SWIG_fail;
18407 }
18408 {
18409 resultobj = wxPyMake_wxObject(result, 0);
18410 }
18411 return resultobj;
18412 fail:
18413 return NULL;
18414 }
18415
18416
18417 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18418 PyObject *resultobj = 0;
18419 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18420 wxEvtHandler *result = 0 ;
18421 void *argp1 = 0 ;
18422 int res1 = 0 ;
18423 PyObject *swig_obj[1] ;
18424
18425 if (!args) SWIG_fail;
18426 swig_obj[0] = args;
18427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18428 if (!SWIG_IsOK(res1)) {
18429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18430 }
18431 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18432 {
18433 PyThreadState* __tstate = wxPyBeginAllowThreads();
18434 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18435 wxPyEndAllowThreads(__tstate);
18436 if (PyErr_Occurred()) SWIG_fail;
18437 }
18438 {
18439 resultobj = wxPyMake_wxObject(result, 0);
18440 }
18441 return resultobj;
18442 fail:
18443 return NULL;
18444 }
18445
18446
18447 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18448 PyObject *resultobj = 0;
18449 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18450 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18451 void *argp1 = 0 ;
18452 int res1 = 0 ;
18453 void *argp2 = 0 ;
18454 int res2 = 0 ;
18455 PyObject * obj0 = 0 ;
18456 PyObject * obj1 = 0 ;
18457 char * kwnames[] = {
18458 (char *) "self",(char *) "handler", NULL
18459 };
18460
18461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18463 if (!SWIG_IsOK(res1)) {
18464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18465 }
18466 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18468 if (!SWIG_IsOK(res2)) {
18469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18470 }
18471 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18472 {
18473 PyThreadState* __tstate = wxPyBeginAllowThreads();
18474 (arg1)->SetNextHandler(arg2);
18475 wxPyEndAllowThreads(__tstate);
18476 if (PyErr_Occurred()) SWIG_fail;
18477 }
18478 resultobj = SWIG_Py_Void();
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18486 PyObject *resultobj = 0;
18487 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18488 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18489 void *argp1 = 0 ;
18490 int res1 = 0 ;
18491 void *argp2 = 0 ;
18492 int res2 = 0 ;
18493 PyObject * obj0 = 0 ;
18494 PyObject * obj1 = 0 ;
18495 char * kwnames[] = {
18496 (char *) "self",(char *) "handler", NULL
18497 };
18498
18499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18501 if (!SWIG_IsOK(res1)) {
18502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18503 }
18504 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18505 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18506 if (!SWIG_IsOK(res2)) {
18507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18508 }
18509 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18510 {
18511 PyThreadState* __tstate = wxPyBeginAllowThreads();
18512 (arg1)->SetPreviousHandler(arg2);
18513 wxPyEndAllowThreads(__tstate);
18514 if (PyErr_Occurred()) SWIG_fail;
18515 }
18516 resultobj = SWIG_Py_Void();
18517 return resultobj;
18518 fail:
18519 return NULL;
18520 }
18521
18522
18523 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18524 PyObject *resultobj = 0;
18525 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18526 bool result;
18527 void *argp1 = 0 ;
18528 int res1 = 0 ;
18529 PyObject *swig_obj[1] ;
18530
18531 if (!args) SWIG_fail;
18532 swig_obj[0] = args;
18533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18534 if (!SWIG_IsOK(res1)) {
18535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18536 }
18537 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 result = (bool)(arg1)->GetEvtHandlerEnabled();
18541 wxPyEndAllowThreads(__tstate);
18542 if (PyErr_Occurred()) SWIG_fail;
18543 }
18544 {
18545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18546 }
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18554 PyObject *resultobj = 0;
18555 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18556 bool arg2 ;
18557 void *argp1 = 0 ;
18558 int res1 = 0 ;
18559 bool val2 ;
18560 int ecode2 = 0 ;
18561 PyObject * obj0 = 0 ;
18562 PyObject * obj1 = 0 ;
18563 char * kwnames[] = {
18564 (char *) "self",(char *) "enabled", NULL
18565 };
18566
18567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18569 if (!SWIG_IsOK(res1)) {
18570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18571 }
18572 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18574 if (!SWIG_IsOK(ecode2)) {
18575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18576 }
18577 arg2 = static_cast< bool >(val2);
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 (arg1)->SetEvtHandlerEnabled(arg2);
18581 wxPyEndAllowThreads(__tstate);
18582 if (PyErr_Occurred()) SWIG_fail;
18583 }
18584 resultobj = SWIG_Py_Void();
18585 return resultobj;
18586 fail:
18587 return NULL;
18588 }
18589
18590
18591 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18592 PyObject *resultobj = 0;
18593 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18594 wxEvent *arg2 = 0 ;
18595 bool result;
18596 void *argp1 = 0 ;
18597 int res1 = 0 ;
18598 void *argp2 = 0 ;
18599 int res2 = 0 ;
18600 PyObject * obj0 = 0 ;
18601 PyObject * obj1 = 0 ;
18602 char * kwnames[] = {
18603 (char *) "self",(char *) "event", NULL
18604 };
18605
18606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18608 if (!SWIG_IsOK(res1)) {
18609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18610 }
18611 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18613 if (!SWIG_IsOK(res2)) {
18614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18615 }
18616 if (!argp2) {
18617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18618 }
18619 arg2 = reinterpret_cast< wxEvent * >(argp2);
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 result = (bool)(arg1)->ProcessEvent(*arg2);
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 {
18627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18628 }
18629 return resultobj;
18630 fail:
18631 return NULL;
18632 }
18633
18634
18635 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18636 PyObject *resultobj = 0;
18637 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18638 wxEvent *arg2 = 0 ;
18639 void *argp1 = 0 ;
18640 int res1 = 0 ;
18641 void *argp2 = 0 ;
18642 int res2 = 0 ;
18643 PyObject * obj0 = 0 ;
18644 PyObject * obj1 = 0 ;
18645 char * kwnames[] = {
18646 (char *) "self",(char *) "event", NULL
18647 };
18648
18649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18651 if (!SWIG_IsOK(res1)) {
18652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18653 }
18654 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18655 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18656 if (!SWIG_IsOK(res2)) {
18657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18658 }
18659 if (!argp2) {
18660 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18661 }
18662 arg2 = reinterpret_cast< wxEvent * >(argp2);
18663 {
18664 PyThreadState* __tstate = wxPyBeginAllowThreads();
18665 (arg1)->AddPendingEvent(*arg2);
18666 wxPyEndAllowThreads(__tstate);
18667 if (PyErr_Occurred()) SWIG_fail;
18668 }
18669 resultobj = SWIG_Py_Void();
18670 return resultobj;
18671 fail:
18672 return NULL;
18673 }
18674
18675
18676 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18677 PyObject *resultobj = 0;
18678 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18679 void *argp1 = 0 ;
18680 int res1 = 0 ;
18681 PyObject *swig_obj[1] ;
18682
18683 if (!args) SWIG_fail;
18684 swig_obj[0] = args;
18685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18686 if (!SWIG_IsOK(res1)) {
18687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18688 }
18689 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 (arg1)->ProcessPendingEvents();
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_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18704 PyObject *resultobj = 0;
18705 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18706 bool arg2 = (bool) true ;
18707 void *argp1 = 0 ;
18708 int res1 = 0 ;
18709 bool val2 ;
18710 int ecode2 = 0 ;
18711 PyObject * obj0 = 0 ;
18712 PyObject * obj1 = 0 ;
18713 char * kwnames[] = {
18714 (char *) "self",(char *) "allow", NULL
18715 };
18716
18717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18721 }
18722 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18723 if (obj1) {
18724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18725 if (!SWIG_IsOK(ecode2)) {
18726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18727 }
18728 arg2 = static_cast< bool >(val2);
18729 }
18730 {
18731 PyThreadState* __tstate = wxPyBeginAllowThreads();
18732 (arg1)->AllowReentrance(arg2);
18733 wxPyEndAllowThreads(__tstate);
18734 if (PyErr_Occurred()) SWIG_fail;
18735 }
18736 resultobj = SWIG_Py_Void();
18737 return resultobj;
18738 fail:
18739 return NULL;
18740 }
18741
18742
18743 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18744 PyObject *resultobj = 0;
18745 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18746 bool result;
18747 void *argp1 = 0 ;
18748 int res1 = 0 ;
18749 PyObject *swig_obj[1] ;
18750
18751 if (!args) SWIG_fail;
18752 swig_obj[0] = args;
18753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18754 if (!SWIG_IsOK(res1)) {
18755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18756 }
18757 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18758 {
18759 PyThreadState* __tstate = wxPyBeginAllowThreads();
18760 result = (bool)(arg1)->IsReentranceAllowed();
18761 wxPyEndAllowThreads(__tstate);
18762 if (PyErr_Occurred()) SWIG_fail;
18763 }
18764 {
18765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18766 }
18767 return resultobj;
18768 fail:
18769 return NULL;
18770 }
18771
18772
18773 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18774 PyObject *resultobj = 0;
18775 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18776 bool result;
18777 void *argp1 = 0 ;
18778 int res1 = 0 ;
18779 PyObject *swig_obj[1] ;
18780
18781 if (!args) SWIG_fail;
18782 swig_obj[0] = args;
18783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18784 if (!SWIG_IsOK(res1)) {
18785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18786 }
18787 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (bool)(arg1)->IsEventHandlingInProgress();
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 {
18795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18796 }
18797 return resultobj;
18798 fail:
18799 return NULL;
18800 }
18801
18802
18803 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18804 PyObject *resultobj = 0;
18805 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18806 int arg2 ;
18807 int arg3 ;
18808 int arg4 ;
18809 PyObject *arg5 = (PyObject *) 0 ;
18810 void *argp1 = 0 ;
18811 int res1 = 0 ;
18812 int val2 ;
18813 int ecode2 = 0 ;
18814 int val3 ;
18815 int ecode3 = 0 ;
18816 int val4 ;
18817 int ecode4 = 0 ;
18818 PyObject * obj0 = 0 ;
18819 PyObject * obj1 = 0 ;
18820 PyObject * obj2 = 0 ;
18821 PyObject * obj3 = 0 ;
18822 PyObject * obj4 = 0 ;
18823 char * kwnames[] = {
18824 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18825 };
18826
18827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18829 if (!SWIG_IsOK(res1)) {
18830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18831 }
18832 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18833 ecode2 = SWIG_AsVal_int(obj1, &val2);
18834 if (!SWIG_IsOK(ecode2)) {
18835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18836 }
18837 arg2 = static_cast< int >(val2);
18838 ecode3 = SWIG_AsVal_int(obj2, &val3);
18839 if (!SWIG_IsOK(ecode3)) {
18840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18841 }
18842 arg3 = static_cast< int >(val3);
18843 ecode4 = SWIG_AsVal_int(obj3, &val4);
18844 if (!SWIG_IsOK(ecode4)) {
18845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18846 }
18847 arg4 = static_cast< int >(val4);
18848 arg5 = obj4;
18849 {
18850 PyThreadState* __tstate = wxPyBeginAllowThreads();
18851 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18852 wxPyEndAllowThreads(__tstate);
18853 if (PyErr_Occurred()) SWIG_fail;
18854 }
18855 resultobj = SWIG_Py_Void();
18856 return resultobj;
18857 fail:
18858 return NULL;
18859 }
18860
18861
18862 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18863 PyObject *resultobj = 0;
18864 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18865 int arg2 ;
18866 int arg3 = (int) -1 ;
18867 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18868 bool result;
18869 void *argp1 = 0 ;
18870 int res1 = 0 ;
18871 int val2 ;
18872 int ecode2 = 0 ;
18873 int val3 ;
18874 int ecode3 = 0 ;
18875 int val4 ;
18876 int ecode4 = 0 ;
18877 PyObject * obj0 = 0 ;
18878 PyObject * obj1 = 0 ;
18879 PyObject * obj2 = 0 ;
18880 PyObject * obj3 = 0 ;
18881 char * kwnames[] = {
18882 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18883 };
18884
18885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18887 if (!SWIG_IsOK(res1)) {
18888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18889 }
18890 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18891 ecode2 = SWIG_AsVal_int(obj1, &val2);
18892 if (!SWIG_IsOK(ecode2)) {
18893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18894 }
18895 arg2 = static_cast< int >(val2);
18896 if (obj2) {
18897 ecode3 = SWIG_AsVal_int(obj2, &val3);
18898 if (!SWIG_IsOK(ecode3)) {
18899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18900 }
18901 arg3 = static_cast< int >(val3);
18902 }
18903 if (obj3) {
18904 ecode4 = SWIG_AsVal_int(obj3, &val4);
18905 if (!SWIG_IsOK(ecode4)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18907 }
18908 arg4 = static_cast< wxEventType >(val4);
18909 }
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18913 wxPyEndAllowThreads(__tstate);
18914 if (PyErr_Occurred()) SWIG_fail;
18915 }
18916 {
18917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18918 }
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = 0;
18927 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18928 PyObject *arg2 = (PyObject *) 0 ;
18929 bool arg3 = (bool) true ;
18930 void *argp1 = 0 ;
18931 int res1 = 0 ;
18932 bool val3 ;
18933 int ecode3 = 0 ;
18934 PyObject * obj0 = 0 ;
18935 PyObject * obj1 = 0 ;
18936 PyObject * obj2 = 0 ;
18937 char * kwnames[] = {
18938 (char *) "self",(char *) "_self",(char *) "incref", NULL
18939 };
18940
18941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18943 if (!SWIG_IsOK(res1)) {
18944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18945 }
18946 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18947 arg2 = obj1;
18948 if (obj2) {
18949 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18950 if (!SWIG_IsOK(ecode3)) {
18951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18952 }
18953 arg3 = static_cast< bool >(val3);
18954 }
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18958 wxPyEndAllowThreads(__tstate);
18959 if (PyErr_Occurred()) SWIG_fail;
18960 }
18961 resultobj = SWIG_Py_Void();
18962 return resultobj;
18963 fail:
18964 return NULL;
18965 }
18966
18967
18968 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18969 PyObject *obj;
18970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18971 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18972 return SWIG_Py_Void();
18973 }
18974
18975 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18976 return SWIG_Python_InitShadowInstance(args);
18977 }
18978
18979 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18980 PyObject *resultobj = 0;
18981 wxEventType result;
18982
18983 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18984 {
18985 PyThreadState* __tstate = wxPyBeginAllowThreads();
18986 result = (wxEventType)wxNewEventType();
18987 wxPyEndAllowThreads(__tstate);
18988 if (PyErr_Occurred()) SWIG_fail;
18989 }
18990 resultobj = SWIG_From_int(static_cast< int >(result));
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18998 PyObject *resultobj = 0;
18999 wxEvent *arg1 = (wxEvent *) 0 ;
19000 void *argp1 = 0 ;
19001 int res1 = 0 ;
19002 PyObject *swig_obj[1] ;
19003
19004 if (!args) SWIG_fail;
19005 swig_obj[0] = args;
19006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
19007 if (!SWIG_IsOK(res1)) {
19008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
19009 }
19010 arg1 = reinterpret_cast< wxEvent * >(argp1);
19011 {
19012 PyThreadState* __tstate = wxPyBeginAllowThreads();
19013 delete arg1;
19014
19015 wxPyEndAllowThreads(__tstate);
19016 if (PyErr_Occurred()) SWIG_fail;
19017 }
19018 resultobj = SWIG_Py_Void();
19019 return resultobj;
19020 fail:
19021 return NULL;
19022 }
19023
19024
19025 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19026 PyObject *resultobj = 0;
19027 wxEvent *arg1 = (wxEvent *) 0 ;
19028 wxEventType arg2 ;
19029 void *argp1 = 0 ;
19030 int res1 = 0 ;
19031 int val2 ;
19032 int ecode2 = 0 ;
19033 PyObject * obj0 = 0 ;
19034 PyObject * obj1 = 0 ;
19035 char * kwnames[] = {
19036 (char *) "self",(char *) "typ", NULL
19037 };
19038
19039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19041 if (!SWIG_IsOK(res1)) {
19042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19043 }
19044 arg1 = reinterpret_cast< wxEvent * >(argp1);
19045 ecode2 = SWIG_AsVal_int(obj1, &val2);
19046 if (!SWIG_IsOK(ecode2)) {
19047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19048 }
19049 arg2 = static_cast< wxEventType >(val2);
19050 {
19051 PyThreadState* __tstate = wxPyBeginAllowThreads();
19052 (arg1)->SetEventType(arg2);
19053 wxPyEndAllowThreads(__tstate);
19054 if (PyErr_Occurred()) SWIG_fail;
19055 }
19056 resultobj = SWIG_Py_Void();
19057 return resultobj;
19058 fail:
19059 return NULL;
19060 }
19061
19062
19063 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19064 PyObject *resultobj = 0;
19065 wxEvent *arg1 = (wxEvent *) 0 ;
19066 wxEventType result;
19067 void *argp1 = 0 ;
19068 int res1 = 0 ;
19069 PyObject *swig_obj[1] ;
19070
19071 if (!args) SWIG_fail;
19072 swig_obj[0] = args;
19073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19074 if (!SWIG_IsOK(res1)) {
19075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19076 }
19077 arg1 = reinterpret_cast< wxEvent * >(argp1);
19078 {
19079 PyThreadState* __tstate = wxPyBeginAllowThreads();
19080 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19081 wxPyEndAllowThreads(__tstate);
19082 if (PyErr_Occurred()) SWIG_fail;
19083 }
19084 resultobj = SWIG_From_int(static_cast< int >(result));
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19092 PyObject *resultobj = 0;
19093 wxEvent *arg1 = (wxEvent *) 0 ;
19094 wxObject *result = 0 ;
19095 void *argp1 = 0 ;
19096 int res1 = 0 ;
19097 PyObject *swig_obj[1] ;
19098
19099 if (!args) SWIG_fail;
19100 swig_obj[0] = args;
19101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19102 if (!SWIG_IsOK(res1)) {
19103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19104 }
19105 arg1 = reinterpret_cast< wxEvent * >(argp1);
19106 {
19107 PyThreadState* __tstate = wxPyBeginAllowThreads();
19108 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19109 wxPyEndAllowThreads(__tstate);
19110 if (PyErr_Occurred()) SWIG_fail;
19111 }
19112 {
19113 resultobj = wxPyMake_wxObject(result, (bool)0);
19114 }
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj = 0;
19123 wxEvent *arg1 = (wxEvent *) 0 ;
19124 wxObject *arg2 = (wxObject *) 0 ;
19125 void *argp1 = 0 ;
19126 int res1 = 0 ;
19127 void *argp2 = 0 ;
19128 int res2 = 0 ;
19129 PyObject * obj0 = 0 ;
19130 PyObject * obj1 = 0 ;
19131 char * kwnames[] = {
19132 (char *) "self",(char *) "obj", NULL
19133 };
19134
19135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19137 if (!SWIG_IsOK(res1)) {
19138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19139 }
19140 arg1 = reinterpret_cast< wxEvent * >(argp1);
19141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19142 if (!SWIG_IsOK(res2)) {
19143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19144 }
19145 arg2 = reinterpret_cast< wxObject * >(argp2);
19146 {
19147 PyThreadState* __tstate = wxPyBeginAllowThreads();
19148 (arg1)->SetEventObject(arg2);
19149 wxPyEndAllowThreads(__tstate);
19150 if (PyErr_Occurred()) SWIG_fail;
19151 }
19152 resultobj = SWIG_Py_Void();
19153 return resultobj;
19154 fail:
19155 return NULL;
19156 }
19157
19158
19159 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19160 PyObject *resultobj = 0;
19161 wxEvent *arg1 = (wxEvent *) 0 ;
19162 long result;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 PyObject *swig_obj[1] ;
19166
19167 if (!args) SWIG_fail;
19168 swig_obj[0] = args;
19169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19170 if (!SWIG_IsOK(res1)) {
19171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19172 }
19173 arg1 = reinterpret_cast< wxEvent * >(argp1);
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19177 wxPyEndAllowThreads(__tstate);
19178 if (PyErr_Occurred()) SWIG_fail;
19179 }
19180 resultobj = SWIG_From_long(static_cast< long >(result));
19181 return resultobj;
19182 fail:
19183 return NULL;
19184 }
19185
19186
19187 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19188 PyObject *resultobj = 0;
19189 wxEvent *arg1 = (wxEvent *) 0 ;
19190 long arg2 = (long) 0 ;
19191 void *argp1 = 0 ;
19192 int res1 = 0 ;
19193 long val2 ;
19194 int ecode2 = 0 ;
19195 PyObject * obj0 = 0 ;
19196 PyObject * obj1 = 0 ;
19197 char * kwnames[] = {
19198 (char *) "self",(char *) "ts", NULL
19199 };
19200
19201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19203 if (!SWIG_IsOK(res1)) {
19204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19205 }
19206 arg1 = reinterpret_cast< wxEvent * >(argp1);
19207 if (obj1) {
19208 ecode2 = SWIG_AsVal_long(obj1, &val2);
19209 if (!SWIG_IsOK(ecode2)) {
19210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19211 }
19212 arg2 = static_cast< long >(val2);
19213 }
19214 {
19215 PyThreadState* __tstate = wxPyBeginAllowThreads();
19216 (arg1)->SetTimestamp(arg2);
19217 wxPyEndAllowThreads(__tstate);
19218 if (PyErr_Occurred()) SWIG_fail;
19219 }
19220 resultobj = SWIG_Py_Void();
19221 return resultobj;
19222 fail:
19223 return NULL;
19224 }
19225
19226
19227 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19228 PyObject *resultobj = 0;
19229 wxEvent *arg1 = (wxEvent *) 0 ;
19230 int result;
19231 void *argp1 = 0 ;
19232 int res1 = 0 ;
19233 PyObject *swig_obj[1] ;
19234
19235 if (!args) SWIG_fail;
19236 swig_obj[0] = args;
19237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19238 if (!SWIG_IsOK(res1)) {
19239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19240 }
19241 arg1 = reinterpret_cast< wxEvent * >(argp1);
19242 {
19243 PyThreadState* __tstate = wxPyBeginAllowThreads();
19244 result = (int)((wxEvent const *)arg1)->GetId();
19245 wxPyEndAllowThreads(__tstate);
19246 if (PyErr_Occurred()) SWIG_fail;
19247 }
19248 resultobj = SWIG_From_int(static_cast< int >(result));
19249 return resultobj;
19250 fail:
19251 return NULL;
19252 }
19253
19254
19255 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19256 PyObject *resultobj = 0;
19257 wxEvent *arg1 = (wxEvent *) 0 ;
19258 int arg2 ;
19259 void *argp1 = 0 ;
19260 int res1 = 0 ;
19261 int val2 ;
19262 int ecode2 = 0 ;
19263 PyObject * obj0 = 0 ;
19264 PyObject * obj1 = 0 ;
19265 char * kwnames[] = {
19266 (char *) "self",(char *) "Id", NULL
19267 };
19268
19269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19271 if (!SWIG_IsOK(res1)) {
19272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19273 }
19274 arg1 = reinterpret_cast< wxEvent * >(argp1);
19275 ecode2 = SWIG_AsVal_int(obj1, &val2);
19276 if (!SWIG_IsOK(ecode2)) {
19277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19278 }
19279 arg2 = static_cast< int >(val2);
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 (arg1)->SetId(arg2);
19283 wxPyEndAllowThreads(__tstate);
19284 if (PyErr_Occurred()) SWIG_fail;
19285 }
19286 resultobj = SWIG_Py_Void();
19287 return resultobj;
19288 fail:
19289 return NULL;
19290 }
19291
19292
19293 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19294 PyObject *resultobj = 0;
19295 wxEvent *arg1 = (wxEvent *) 0 ;
19296 bool result;
19297 void *argp1 = 0 ;
19298 int res1 = 0 ;
19299 PyObject *swig_obj[1] ;
19300
19301 if (!args) SWIG_fail;
19302 swig_obj[0] = args;
19303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19304 if (!SWIG_IsOK(res1)) {
19305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19306 }
19307 arg1 = reinterpret_cast< wxEvent * >(argp1);
19308 {
19309 PyThreadState* __tstate = wxPyBeginAllowThreads();
19310 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 {
19315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19316 }
19317 return resultobj;
19318 fail:
19319 return NULL;
19320 }
19321
19322
19323 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19324 PyObject *resultobj = 0;
19325 wxEvent *arg1 = (wxEvent *) 0 ;
19326 bool arg2 = (bool) true ;
19327 void *argp1 = 0 ;
19328 int res1 = 0 ;
19329 bool val2 ;
19330 int ecode2 = 0 ;
19331 PyObject * obj0 = 0 ;
19332 PyObject * obj1 = 0 ;
19333 char * kwnames[] = {
19334 (char *) "self",(char *) "skip", NULL
19335 };
19336
19337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19339 if (!SWIG_IsOK(res1)) {
19340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19341 }
19342 arg1 = reinterpret_cast< wxEvent * >(argp1);
19343 if (obj1) {
19344 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19345 if (!SWIG_IsOK(ecode2)) {
19346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19347 }
19348 arg2 = static_cast< bool >(val2);
19349 }
19350 {
19351 PyThreadState* __tstate = wxPyBeginAllowThreads();
19352 (arg1)->Skip(arg2);
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 resultobj = SWIG_Py_Void();
19357 return resultobj;
19358 fail:
19359 return NULL;
19360 }
19361
19362
19363 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19364 PyObject *resultobj = 0;
19365 wxEvent *arg1 = (wxEvent *) 0 ;
19366 bool result;
19367 void *argp1 = 0 ;
19368 int res1 = 0 ;
19369 PyObject *swig_obj[1] ;
19370
19371 if (!args) SWIG_fail;
19372 swig_obj[0] = args;
19373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19374 if (!SWIG_IsOK(res1)) {
19375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19376 }
19377 arg1 = reinterpret_cast< wxEvent * >(argp1);
19378 {
19379 PyThreadState* __tstate = wxPyBeginAllowThreads();
19380 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19381 wxPyEndAllowThreads(__tstate);
19382 if (PyErr_Occurred()) SWIG_fail;
19383 }
19384 {
19385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19386 }
19387 return resultobj;
19388 fail:
19389 return NULL;
19390 }
19391
19392
19393 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19394 PyObject *resultobj = 0;
19395 wxEvent *arg1 = (wxEvent *) 0 ;
19396 bool result;
19397 void *argp1 = 0 ;
19398 int res1 = 0 ;
19399 PyObject *swig_obj[1] ;
19400
19401 if (!args) SWIG_fail;
19402 swig_obj[0] = args;
19403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19404 if (!SWIG_IsOK(res1)) {
19405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19406 }
19407 arg1 = reinterpret_cast< wxEvent * >(argp1);
19408 {
19409 PyThreadState* __tstate = wxPyBeginAllowThreads();
19410 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19411 wxPyEndAllowThreads(__tstate);
19412 if (PyErr_Occurred()) SWIG_fail;
19413 }
19414 {
19415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19416 }
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19424 PyObject *resultobj = 0;
19425 wxEvent *arg1 = (wxEvent *) 0 ;
19426 int result;
19427 void *argp1 = 0 ;
19428 int res1 = 0 ;
19429 PyObject *swig_obj[1] ;
19430
19431 if (!args) SWIG_fail;
19432 swig_obj[0] = args;
19433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19434 if (!SWIG_IsOK(res1)) {
19435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19436 }
19437 arg1 = reinterpret_cast< wxEvent * >(argp1);
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = (int)(arg1)->StopPropagation();
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 resultobj = SWIG_From_int(static_cast< int >(result));
19445 return resultobj;
19446 fail:
19447 return NULL;
19448 }
19449
19450
19451 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj = 0;
19453 wxEvent *arg1 = (wxEvent *) 0 ;
19454 int arg2 ;
19455 void *argp1 = 0 ;
19456 int res1 = 0 ;
19457 int val2 ;
19458 int ecode2 = 0 ;
19459 PyObject * obj0 = 0 ;
19460 PyObject * obj1 = 0 ;
19461 char * kwnames[] = {
19462 (char *) "self",(char *) "propagationLevel", NULL
19463 };
19464
19465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19467 if (!SWIG_IsOK(res1)) {
19468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19469 }
19470 arg1 = reinterpret_cast< wxEvent * >(argp1);
19471 ecode2 = SWIG_AsVal_int(obj1, &val2);
19472 if (!SWIG_IsOK(ecode2)) {
19473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19474 }
19475 arg2 = static_cast< int >(val2);
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 (arg1)->ResumePropagation(arg2);
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = SWIG_Py_Void();
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19490 PyObject *resultobj = 0;
19491 wxEvent *arg1 = (wxEvent *) 0 ;
19492 wxEvent *result = 0 ;
19493 void *argp1 = 0 ;
19494 int res1 = 0 ;
19495 PyObject *swig_obj[1] ;
19496
19497 if (!args) SWIG_fail;
19498 swig_obj[0] = args;
19499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19500 if (!SWIG_IsOK(res1)) {
19501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19502 }
19503 arg1 = reinterpret_cast< wxEvent * >(argp1);
19504 {
19505 PyThreadState* __tstate = wxPyBeginAllowThreads();
19506 result = (wxEvent *)(arg1)->Clone();
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19511 return resultobj;
19512 fail:
19513 return NULL;
19514 }
19515
19516
19517 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19518 PyObject *obj;
19519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19520 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19521 return SWIG_Py_Void();
19522 }
19523
19524 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19525 PyObject *resultobj = 0;
19526 wxEvent *arg1 = 0 ;
19527 wxPropagationDisabler *result = 0 ;
19528 void *argp1 = 0 ;
19529 int res1 = 0 ;
19530 PyObject * obj0 = 0 ;
19531 char * kwnames[] = {
19532 (char *) "event", NULL
19533 };
19534
19535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19536 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19537 if (!SWIG_IsOK(res1)) {
19538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19539 }
19540 if (!argp1) {
19541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19542 }
19543 arg1 = reinterpret_cast< wxEvent * >(argp1);
19544 {
19545 PyThreadState* __tstate = wxPyBeginAllowThreads();
19546 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19551 return resultobj;
19552 fail:
19553 return NULL;
19554 }
19555
19556
19557 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19558 PyObject *resultobj = 0;
19559 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19560 void *argp1 = 0 ;
19561 int res1 = 0 ;
19562 PyObject *swig_obj[1] ;
19563
19564 if (!args) SWIG_fail;
19565 swig_obj[0] = args;
19566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19567 if (!SWIG_IsOK(res1)) {
19568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19569 }
19570 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 delete arg1;
19574
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 resultobj = SWIG_Py_Void();
19579 return resultobj;
19580 fail:
19581 return NULL;
19582 }
19583
19584
19585 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19586 PyObject *obj;
19587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19588 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19589 return SWIG_Py_Void();
19590 }
19591
19592 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19593 return SWIG_Python_InitShadowInstance(args);
19594 }
19595
19596 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19597 PyObject *resultobj = 0;
19598 wxEvent *arg1 = 0 ;
19599 wxPropagateOnce *result = 0 ;
19600 void *argp1 = 0 ;
19601 int res1 = 0 ;
19602 PyObject * obj0 = 0 ;
19603 char * kwnames[] = {
19604 (char *) "event", NULL
19605 };
19606
19607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19608 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19609 if (!SWIG_IsOK(res1)) {
19610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19611 }
19612 if (!argp1) {
19613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19614 }
19615 arg1 = reinterpret_cast< wxEvent * >(argp1);
19616 {
19617 PyThreadState* __tstate = wxPyBeginAllowThreads();
19618 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19630 PyObject *resultobj = 0;
19631 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19632 void *argp1 = 0 ;
19633 int res1 = 0 ;
19634 PyObject *swig_obj[1] ;
19635
19636 if (!args) SWIG_fail;
19637 swig_obj[0] = args;
19638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19639 if (!SWIG_IsOK(res1)) {
19640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19641 }
19642 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19643 {
19644 PyThreadState* __tstate = wxPyBeginAllowThreads();
19645 delete arg1;
19646
19647 wxPyEndAllowThreads(__tstate);
19648 if (PyErr_Occurred()) SWIG_fail;
19649 }
19650 resultobj = SWIG_Py_Void();
19651 return resultobj;
19652 fail:
19653 return NULL;
19654 }
19655
19656
19657 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19658 PyObject *obj;
19659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19660 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19661 return SWIG_Py_Void();
19662 }
19663
19664 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19665 return SWIG_Python_InitShadowInstance(args);
19666 }
19667
19668 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19669 PyObject *resultobj = 0;
19670 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19671 int arg2 = (int) 0 ;
19672 wxCommandEvent *result = 0 ;
19673 int val1 ;
19674 int ecode1 = 0 ;
19675 int val2 ;
19676 int ecode2 = 0 ;
19677 PyObject * obj0 = 0 ;
19678 PyObject * obj1 = 0 ;
19679 char * kwnames[] = {
19680 (char *) "commandType",(char *) "winid", NULL
19681 };
19682
19683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19684 if (obj0) {
19685 ecode1 = SWIG_AsVal_int(obj0, &val1);
19686 if (!SWIG_IsOK(ecode1)) {
19687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19688 }
19689 arg1 = static_cast< wxEventType >(val1);
19690 }
19691 if (obj1) {
19692 ecode2 = SWIG_AsVal_int(obj1, &val2);
19693 if (!SWIG_IsOK(ecode2)) {
19694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19695 }
19696 arg2 = static_cast< int >(val2);
19697 }
19698 {
19699 PyThreadState* __tstate = wxPyBeginAllowThreads();
19700 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19712 PyObject *resultobj = 0;
19713 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19714 int result;
19715 void *argp1 = 0 ;
19716 int res1 = 0 ;
19717 PyObject *swig_obj[1] ;
19718
19719 if (!args) SWIG_fail;
19720 swig_obj[0] = args;
19721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19722 if (!SWIG_IsOK(res1)) {
19723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19724 }
19725 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19726 {
19727 PyThreadState* __tstate = wxPyBeginAllowThreads();
19728 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19729 wxPyEndAllowThreads(__tstate);
19730 if (PyErr_Occurred()) SWIG_fail;
19731 }
19732 resultobj = SWIG_From_int(static_cast< int >(result));
19733 return resultobj;
19734 fail:
19735 return NULL;
19736 }
19737
19738
19739 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19740 PyObject *resultobj = 0;
19741 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19742 wxString *arg2 = 0 ;
19743 void *argp1 = 0 ;
19744 int res1 = 0 ;
19745 bool temp2 = false ;
19746 PyObject * obj0 = 0 ;
19747 PyObject * obj1 = 0 ;
19748 char * kwnames[] = {
19749 (char *) "self",(char *) "s", NULL
19750 };
19751
19752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19754 if (!SWIG_IsOK(res1)) {
19755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19756 }
19757 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19758 {
19759 arg2 = wxString_in_helper(obj1);
19760 if (arg2 == NULL) SWIG_fail;
19761 temp2 = true;
19762 }
19763 {
19764 PyThreadState* __tstate = wxPyBeginAllowThreads();
19765 (arg1)->SetString((wxString const &)*arg2);
19766 wxPyEndAllowThreads(__tstate);
19767 if (PyErr_Occurred()) SWIG_fail;
19768 }
19769 resultobj = SWIG_Py_Void();
19770 {
19771 if (temp2)
19772 delete arg2;
19773 }
19774 return resultobj;
19775 fail:
19776 {
19777 if (temp2)
19778 delete arg2;
19779 }
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19785 PyObject *resultobj = 0;
19786 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19787 wxString result;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 PyObject *swig_obj[1] ;
19791
19792 if (!args) SWIG_fail;
19793 swig_obj[0] = args;
19794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19795 if (!SWIG_IsOK(res1)) {
19796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19797 }
19798 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 result = ((wxCommandEvent const *)arg1)->GetString();
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 {
19806 #if wxUSE_UNICODE
19807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19808 #else
19809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19810 #endif
19811 }
19812 return resultobj;
19813 fail:
19814 return NULL;
19815 }
19816
19817
19818 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19819 PyObject *resultobj = 0;
19820 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19821 bool result;
19822 void *argp1 = 0 ;
19823 int res1 = 0 ;
19824 PyObject *swig_obj[1] ;
19825
19826 if (!args) SWIG_fail;
19827 swig_obj[0] = args;
19828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19829 if (!SWIG_IsOK(res1)) {
19830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19831 }
19832 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19836 wxPyEndAllowThreads(__tstate);
19837 if (PyErr_Occurred()) SWIG_fail;
19838 }
19839 {
19840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19841 }
19842 return resultobj;
19843 fail:
19844 return NULL;
19845 }
19846
19847
19848 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19849 PyObject *resultobj = 0;
19850 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19851 bool result;
19852 void *argp1 = 0 ;
19853 int res1 = 0 ;
19854 PyObject *swig_obj[1] ;
19855
19856 if (!args) SWIG_fail;
19857 swig_obj[0] = args;
19858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19859 if (!SWIG_IsOK(res1)) {
19860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19861 }
19862 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19866 wxPyEndAllowThreads(__tstate);
19867 if (PyErr_Occurred()) SWIG_fail;
19868 }
19869 {
19870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19871 }
19872 return resultobj;
19873 fail:
19874 return NULL;
19875 }
19876
19877
19878 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19879 PyObject *resultobj = 0;
19880 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19881 long arg2 ;
19882 void *argp1 = 0 ;
19883 int res1 = 0 ;
19884 long val2 ;
19885 int ecode2 = 0 ;
19886 PyObject * obj0 = 0 ;
19887 PyObject * obj1 = 0 ;
19888 char * kwnames[] = {
19889 (char *) "self",(char *) "extraLong", NULL
19890 };
19891
19892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19894 if (!SWIG_IsOK(res1)) {
19895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19896 }
19897 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19898 ecode2 = SWIG_AsVal_long(obj1, &val2);
19899 if (!SWIG_IsOK(ecode2)) {
19900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19901 }
19902 arg2 = static_cast< long >(val2);
19903 {
19904 PyThreadState* __tstate = wxPyBeginAllowThreads();
19905 (arg1)->SetExtraLong(arg2);
19906 wxPyEndAllowThreads(__tstate);
19907 if (PyErr_Occurred()) SWIG_fail;
19908 }
19909 resultobj = SWIG_Py_Void();
19910 return resultobj;
19911 fail:
19912 return NULL;
19913 }
19914
19915
19916 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19917 PyObject *resultobj = 0;
19918 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19919 long result;
19920 void *argp1 = 0 ;
19921 int res1 = 0 ;
19922 PyObject *swig_obj[1] ;
19923
19924 if (!args) SWIG_fail;
19925 swig_obj[0] = args;
19926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19927 if (!SWIG_IsOK(res1)) {
19928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19929 }
19930 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 resultobj = SWIG_From_long(static_cast< long >(result));
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19945 PyObject *resultobj = 0;
19946 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19947 int arg2 ;
19948 void *argp1 = 0 ;
19949 int res1 = 0 ;
19950 int val2 ;
19951 int ecode2 = 0 ;
19952 PyObject * obj0 = 0 ;
19953 PyObject * obj1 = 0 ;
19954 char * kwnames[] = {
19955 (char *) "self",(char *) "i", NULL
19956 };
19957
19958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19960 if (!SWIG_IsOK(res1)) {
19961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19962 }
19963 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19964 ecode2 = SWIG_AsVal_int(obj1, &val2);
19965 if (!SWIG_IsOK(ecode2)) {
19966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19967 }
19968 arg2 = static_cast< int >(val2);
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 (arg1)->SetInt(arg2);
19972 wxPyEndAllowThreads(__tstate);
19973 if (PyErr_Occurred()) SWIG_fail;
19974 }
19975 resultobj = SWIG_Py_Void();
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19983 PyObject *resultobj = 0;
19984 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19985 int result;
19986 void *argp1 = 0 ;
19987 int res1 = 0 ;
19988 PyObject *swig_obj[1] ;
19989
19990 if (!args) SWIG_fail;
19991 swig_obj[0] = args;
19992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19993 if (!SWIG_IsOK(res1)) {
19994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19995 }
19996 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19997 {
19998 PyThreadState* __tstate = wxPyBeginAllowThreads();
19999 result = (int)((wxCommandEvent const *)arg1)->GetInt();
20000 wxPyEndAllowThreads(__tstate);
20001 if (PyErr_Occurred()) SWIG_fail;
20002 }
20003 resultobj = SWIG_From_int(static_cast< int >(result));
20004 return resultobj;
20005 fail:
20006 return NULL;
20007 }
20008
20009
20010 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20011 PyObject *resultobj = 0;
20012 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20013 PyObject *result = 0 ;
20014 void *argp1 = 0 ;
20015 int res1 = 0 ;
20016 PyObject *swig_obj[1] ;
20017
20018 if (!args) SWIG_fail;
20019 swig_obj[0] = args;
20020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20021 if (!SWIG_IsOK(res1)) {
20022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20023 }
20024 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20025 {
20026 PyThreadState* __tstate = wxPyBeginAllowThreads();
20027 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20028 wxPyEndAllowThreads(__tstate);
20029 if (PyErr_Occurred()) SWIG_fail;
20030 }
20031 resultobj = result;
20032 return resultobj;
20033 fail:
20034 return NULL;
20035 }
20036
20037
20038 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20039 PyObject *resultobj = 0;
20040 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20041 PyObject *arg2 = (PyObject *) 0 ;
20042 void *argp1 = 0 ;
20043 int res1 = 0 ;
20044 PyObject * obj0 = 0 ;
20045 PyObject * obj1 = 0 ;
20046 char * kwnames[] = {
20047 (char *) "self",(char *) "clientData", NULL
20048 };
20049
20050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20052 if (!SWIG_IsOK(res1)) {
20053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20054 }
20055 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20056 arg2 = obj1;
20057 {
20058 PyThreadState* __tstate = wxPyBeginAllowThreads();
20059 wxCommandEvent_SetClientData(arg1,arg2);
20060 wxPyEndAllowThreads(__tstate);
20061 if (PyErr_Occurred()) SWIG_fail;
20062 }
20063 resultobj = SWIG_Py_Void();
20064 return resultobj;
20065 fail:
20066 return NULL;
20067 }
20068
20069
20070 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20071 PyObject *resultobj = 0;
20072 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20073 wxEvent *result = 0 ;
20074 void *argp1 = 0 ;
20075 int res1 = 0 ;
20076 PyObject *swig_obj[1] ;
20077
20078 if (!args) SWIG_fail;
20079 swig_obj[0] = args;
20080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20081 if (!SWIG_IsOK(res1)) {
20082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20083 }
20084 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20085 {
20086 PyThreadState* __tstate = wxPyBeginAllowThreads();
20087 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20088 wxPyEndAllowThreads(__tstate);
20089 if (PyErr_Occurred()) SWIG_fail;
20090 }
20091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20092 return resultobj;
20093 fail:
20094 return NULL;
20095 }
20096
20097
20098 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20099 PyObject *obj;
20100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20101 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20102 return SWIG_Py_Void();
20103 }
20104
20105 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20106 return SWIG_Python_InitShadowInstance(args);
20107 }
20108
20109 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj = 0;
20111 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20112 int arg2 = (int) 0 ;
20113 wxNotifyEvent *result = 0 ;
20114 int val1 ;
20115 int ecode1 = 0 ;
20116 int val2 ;
20117 int ecode2 = 0 ;
20118 PyObject * obj0 = 0 ;
20119 PyObject * obj1 = 0 ;
20120 char * kwnames[] = {
20121 (char *) "commandType",(char *) "winid", NULL
20122 };
20123
20124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20125 if (obj0) {
20126 ecode1 = SWIG_AsVal_int(obj0, &val1);
20127 if (!SWIG_IsOK(ecode1)) {
20128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20129 }
20130 arg1 = static_cast< wxEventType >(val1);
20131 }
20132 if (obj1) {
20133 ecode2 = SWIG_AsVal_int(obj1, &val2);
20134 if (!SWIG_IsOK(ecode2)) {
20135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20136 }
20137 arg2 = static_cast< int >(val2);
20138 }
20139 {
20140 PyThreadState* __tstate = wxPyBeginAllowThreads();
20141 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20142 wxPyEndAllowThreads(__tstate);
20143 if (PyErr_Occurred()) SWIG_fail;
20144 }
20145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20153 PyObject *resultobj = 0;
20154 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20155 void *argp1 = 0 ;
20156 int res1 = 0 ;
20157 PyObject *swig_obj[1] ;
20158
20159 if (!args) SWIG_fail;
20160 swig_obj[0] = args;
20161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20162 if (!SWIG_IsOK(res1)) {
20163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20164 }
20165 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20166 {
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 (arg1)->Veto();
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 resultobj = SWIG_Py_Void();
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20180 PyObject *resultobj = 0;
20181 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20182 void *argp1 = 0 ;
20183 int res1 = 0 ;
20184 PyObject *swig_obj[1] ;
20185
20186 if (!args) SWIG_fail;
20187 swig_obj[0] = args;
20188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20189 if (!SWIG_IsOK(res1)) {
20190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20191 }
20192 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20193 {
20194 PyThreadState* __tstate = wxPyBeginAllowThreads();
20195 (arg1)->Allow();
20196 wxPyEndAllowThreads(__tstate);
20197 if (PyErr_Occurred()) SWIG_fail;
20198 }
20199 resultobj = SWIG_Py_Void();
20200 return resultobj;
20201 fail:
20202 return NULL;
20203 }
20204
20205
20206 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20207 PyObject *resultobj = 0;
20208 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20209 bool result;
20210 void *argp1 = 0 ;
20211 int res1 = 0 ;
20212 PyObject *swig_obj[1] ;
20213
20214 if (!args) SWIG_fail;
20215 swig_obj[0] = args;
20216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20217 if (!SWIG_IsOK(res1)) {
20218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20219 }
20220 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 result = (bool)(arg1)->IsAllowed();
20224 wxPyEndAllowThreads(__tstate);
20225 if (PyErr_Occurred()) SWIG_fail;
20226 }
20227 {
20228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20229 }
20230 return resultobj;
20231 fail:
20232 return NULL;
20233 }
20234
20235
20236 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20237 PyObject *obj;
20238 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20239 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20240 return SWIG_Py_Void();
20241 }
20242
20243 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20244 return SWIG_Python_InitShadowInstance(args);
20245 }
20246
20247 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20248 PyObject *resultobj = 0;
20249 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20250 int arg2 = (int) 0 ;
20251 int arg3 = (int) 0 ;
20252 int arg4 = (int) 0 ;
20253 wxScrollEvent *result = 0 ;
20254 int val1 ;
20255 int ecode1 = 0 ;
20256 int val2 ;
20257 int ecode2 = 0 ;
20258 int val3 ;
20259 int ecode3 = 0 ;
20260 int val4 ;
20261 int ecode4 = 0 ;
20262 PyObject * obj0 = 0 ;
20263 PyObject * obj1 = 0 ;
20264 PyObject * obj2 = 0 ;
20265 PyObject * obj3 = 0 ;
20266 char * kwnames[] = {
20267 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20268 };
20269
20270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20271 if (obj0) {
20272 ecode1 = SWIG_AsVal_int(obj0, &val1);
20273 if (!SWIG_IsOK(ecode1)) {
20274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20275 }
20276 arg1 = static_cast< wxEventType >(val1);
20277 }
20278 if (obj1) {
20279 ecode2 = SWIG_AsVal_int(obj1, &val2);
20280 if (!SWIG_IsOK(ecode2)) {
20281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20282 }
20283 arg2 = static_cast< int >(val2);
20284 }
20285 if (obj2) {
20286 ecode3 = SWIG_AsVal_int(obj2, &val3);
20287 if (!SWIG_IsOK(ecode3)) {
20288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20289 }
20290 arg3 = static_cast< int >(val3);
20291 }
20292 if (obj3) {
20293 ecode4 = SWIG_AsVal_int(obj3, &val4);
20294 if (!SWIG_IsOK(ecode4)) {
20295 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20296 }
20297 arg4 = static_cast< int >(val4);
20298 }
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20302 wxPyEndAllowThreads(__tstate);
20303 if (PyErr_Occurred()) SWIG_fail;
20304 }
20305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 PyObject *resultobj = 0;
20314 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20315 int result;
20316 void *argp1 = 0 ;
20317 int res1 = 0 ;
20318 PyObject *swig_obj[1] ;
20319
20320 if (!args) SWIG_fail;
20321 swig_obj[0] = args;
20322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20323 if (!SWIG_IsOK(res1)) {
20324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20325 }
20326 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20330 wxPyEndAllowThreads(__tstate);
20331 if (PyErr_Occurred()) SWIG_fail;
20332 }
20333 resultobj = SWIG_From_int(static_cast< int >(result));
20334 return resultobj;
20335 fail:
20336 return NULL;
20337 }
20338
20339
20340 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20341 PyObject *resultobj = 0;
20342 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20343 int result;
20344 void *argp1 = 0 ;
20345 int res1 = 0 ;
20346 PyObject *swig_obj[1] ;
20347
20348 if (!args) SWIG_fail;
20349 swig_obj[0] = args;
20350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20351 if (!SWIG_IsOK(res1)) {
20352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20353 }
20354 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20355 {
20356 PyThreadState* __tstate = wxPyBeginAllowThreads();
20357 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20358 wxPyEndAllowThreads(__tstate);
20359 if (PyErr_Occurred()) SWIG_fail;
20360 }
20361 resultobj = SWIG_From_int(static_cast< int >(result));
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20369 PyObject *resultobj = 0;
20370 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20371 int arg2 ;
20372 void *argp1 = 0 ;
20373 int res1 = 0 ;
20374 int val2 ;
20375 int ecode2 = 0 ;
20376 PyObject * obj0 = 0 ;
20377 PyObject * obj1 = 0 ;
20378 char * kwnames[] = {
20379 (char *) "self",(char *) "orient", NULL
20380 };
20381
20382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20384 if (!SWIG_IsOK(res1)) {
20385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20386 }
20387 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20388 ecode2 = SWIG_AsVal_int(obj1, &val2);
20389 if (!SWIG_IsOK(ecode2)) {
20390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20391 }
20392 arg2 = static_cast< int >(val2);
20393 {
20394 PyThreadState* __tstate = wxPyBeginAllowThreads();
20395 (arg1)->SetOrientation(arg2);
20396 wxPyEndAllowThreads(__tstate);
20397 if (PyErr_Occurred()) SWIG_fail;
20398 }
20399 resultobj = SWIG_Py_Void();
20400 return resultobj;
20401 fail:
20402 return NULL;
20403 }
20404
20405
20406 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20407 PyObject *resultobj = 0;
20408 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20409 int arg2 ;
20410 void *argp1 = 0 ;
20411 int res1 = 0 ;
20412 int val2 ;
20413 int ecode2 = 0 ;
20414 PyObject * obj0 = 0 ;
20415 PyObject * obj1 = 0 ;
20416 char * kwnames[] = {
20417 (char *) "self",(char *) "pos", NULL
20418 };
20419
20420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20422 if (!SWIG_IsOK(res1)) {
20423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20424 }
20425 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20426 ecode2 = SWIG_AsVal_int(obj1, &val2);
20427 if (!SWIG_IsOK(ecode2)) {
20428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20429 }
20430 arg2 = static_cast< int >(val2);
20431 {
20432 PyThreadState* __tstate = wxPyBeginAllowThreads();
20433 (arg1)->SetPosition(arg2);
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 resultobj = SWIG_Py_Void();
20438 return resultobj;
20439 fail:
20440 return NULL;
20441 }
20442
20443
20444 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20445 PyObject *obj;
20446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20447 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20448 return SWIG_Py_Void();
20449 }
20450
20451 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20452 return SWIG_Python_InitShadowInstance(args);
20453 }
20454
20455 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj = 0;
20457 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20458 int arg2 = (int) 0 ;
20459 int arg3 = (int) 0 ;
20460 wxScrollWinEvent *result = 0 ;
20461 int val1 ;
20462 int ecode1 = 0 ;
20463 int val2 ;
20464 int ecode2 = 0 ;
20465 int val3 ;
20466 int ecode3 = 0 ;
20467 PyObject * obj0 = 0 ;
20468 PyObject * obj1 = 0 ;
20469 PyObject * obj2 = 0 ;
20470 char * kwnames[] = {
20471 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20472 };
20473
20474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20475 if (obj0) {
20476 ecode1 = SWIG_AsVal_int(obj0, &val1);
20477 if (!SWIG_IsOK(ecode1)) {
20478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20479 }
20480 arg1 = static_cast< wxEventType >(val1);
20481 }
20482 if (obj1) {
20483 ecode2 = SWIG_AsVal_int(obj1, &val2);
20484 if (!SWIG_IsOK(ecode2)) {
20485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20486 }
20487 arg2 = static_cast< int >(val2);
20488 }
20489 if (obj2) {
20490 ecode3 = SWIG_AsVal_int(obj2, &val3);
20491 if (!SWIG_IsOK(ecode3)) {
20492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20493 }
20494 arg3 = static_cast< int >(val3);
20495 }
20496 {
20497 PyThreadState* __tstate = wxPyBeginAllowThreads();
20498 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20499 wxPyEndAllowThreads(__tstate);
20500 if (PyErr_Occurred()) SWIG_fail;
20501 }
20502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20510 PyObject *resultobj = 0;
20511 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20512 int result;
20513 void *argp1 = 0 ;
20514 int res1 = 0 ;
20515 PyObject *swig_obj[1] ;
20516
20517 if (!args) SWIG_fail;
20518 swig_obj[0] = args;
20519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20520 if (!SWIG_IsOK(res1)) {
20521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20522 }
20523 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 resultobj = SWIG_From_int(static_cast< int >(result));
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *resultobj = 0;
20539 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20540 int result;
20541 void *argp1 = 0 ;
20542 int res1 = 0 ;
20543 PyObject *swig_obj[1] ;
20544
20545 if (!args) SWIG_fail;
20546 swig_obj[0] = args;
20547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20548 if (!SWIG_IsOK(res1)) {
20549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20550 }
20551 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20552 {
20553 PyThreadState* __tstate = wxPyBeginAllowThreads();
20554 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 resultobj = SWIG_From_int(static_cast< int >(result));
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj = 0;
20567 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20568 int arg2 ;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 int val2 ;
20572 int ecode2 = 0 ;
20573 PyObject * obj0 = 0 ;
20574 PyObject * obj1 = 0 ;
20575 char * kwnames[] = {
20576 (char *) "self",(char *) "orient", NULL
20577 };
20578
20579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20581 if (!SWIG_IsOK(res1)) {
20582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20583 }
20584 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20585 ecode2 = SWIG_AsVal_int(obj1, &val2);
20586 if (!SWIG_IsOK(ecode2)) {
20587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20588 }
20589 arg2 = static_cast< int >(val2);
20590 {
20591 PyThreadState* __tstate = wxPyBeginAllowThreads();
20592 (arg1)->SetOrientation(arg2);
20593 wxPyEndAllowThreads(__tstate);
20594 if (PyErr_Occurred()) SWIG_fail;
20595 }
20596 resultobj = SWIG_Py_Void();
20597 return resultobj;
20598 fail:
20599 return NULL;
20600 }
20601
20602
20603 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20604 PyObject *resultobj = 0;
20605 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20606 int arg2 ;
20607 void *argp1 = 0 ;
20608 int res1 = 0 ;
20609 int val2 ;
20610 int ecode2 = 0 ;
20611 PyObject * obj0 = 0 ;
20612 PyObject * obj1 = 0 ;
20613 char * kwnames[] = {
20614 (char *) "self",(char *) "pos", NULL
20615 };
20616
20617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20619 if (!SWIG_IsOK(res1)) {
20620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20621 }
20622 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20623 ecode2 = SWIG_AsVal_int(obj1, &val2);
20624 if (!SWIG_IsOK(ecode2)) {
20625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20626 }
20627 arg2 = static_cast< int >(val2);
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 (arg1)->SetPosition(arg2);
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 resultobj = SWIG_Py_Void();
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20642 PyObject *obj;
20643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20644 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20645 return SWIG_Py_Void();
20646 }
20647
20648 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20649 return SWIG_Python_InitShadowInstance(args);
20650 }
20651
20652 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj = 0;
20654 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20655 wxMouseEvent *result = 0 ;
20656 int val1 ;
20657 int ecode1 = 0 ;
20658 PyObject * obj0 = 0 ;
20659 char * kwnames[] = {
20660 (char *) "mouseType", NULL
20661 };
20662
20663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20664 if (obj0) {
20665 ecode1 = SWIG_AsVal_int(obj0, &val1);
20666 if (!SWIG_IsOK(ecode1)) {
20667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20668 }
20669 arg1 = static_cast< wxEventType >(val1);
20670 }
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
20678 return resultobj;
20679 fail:
20680 return NULL;
20681 }
20682
20683
20684 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20685 PyObject *resultobj = 0;
20686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20687 bool result;
20688 void *argp1 = 0 ;
20689 int res1 = 0 ;
20690 PyObject *swig_obj[1] ;
20691
20692 if (!args) SWIG_fail;
20693 swig_obj[0] = args;
20694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20695 if (!SWIG_IsOK(res1)) {
20696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20697 }
20698 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20699 {
20700 PyThreadState* __tstate = wxPyBeginAllowThreads();
20701 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20702 wxPyEndAllowThreads(__tstate);
20703 if (PyErr_Occurred()) SWIG_fail;
20704 }
20705 {
20706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20707 }
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20715 PyObject *resultobj = 0;
20716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20717 int arg2 = (int) wxMOUSE_BTN_ANY ;
20718 bool result;
20719 void *argp1 = 0 ;
20720 int res1 = 0 ;
20721 int val2 ;
20722 int ecode2 = 0 ;
20723 PyObject * obj0 = 0 ;
20724 PyObject * obj1 = 0 ;
20725 char * kwnames[] = {
20726 (char *) "self",(char *) "but", NULL
20727 };
20728
20729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20731 if (!SWIG_IsOK(res1)) {
20732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20733 }
20734 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20735 if (obj1) {
20736 ecode2 = SWIG_AsVal_int(obj1, &val2);
20737 if (!SWIG_IsOK(ecode2)) {
20738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20739 }
20740 arg2 = static_cast< int >(val2);
20741 }
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 {
20749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20750 }
20751 return resultobj;
20752 fail:
20753 return NULL;
20754 }
20755
20756
20757 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20758 PyObject *resultobj = 0;
20759 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20760 int arg2 = (int) wxMOUSE_BTN_ANY ;
20761 bool result;
20762 void *argp1 = 0 ;
20763 int res1 = 0 ;
20764 int val2 ;
20765 int ecode2 = 0 ;
20766 PyObject * obj0 = 0 ;
20767 PyObject * obj1 = 0 ;
20768 char * kwnames[] = {
20769 (char *) "self",(char *) "but", NULL
20770 };
20771
20772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20774 if (!SWIG_IsOK(res1)) {
20775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20776 }
20777 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20778 if (obj1) {
20779 ecode2 = SWIG_AsVal_int(obj1, &val2);
20780 if (!SWIG_IsOK(ecode2)) {
20781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20782 }
20783 arg2 = static_cast< int >(val2);
20784 }
20785 {
20786 PyThreadState* __tstate = wxPyBeginAllowThreads();
20787 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20788 wxPyEndAllowThreads(__tstate);
20789 if (PyErr_Occurred()) SWIG_fail;
20790 }
20791 {
20792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20793 }
20794 return resultobj;
20795 fail:
20796 return NULL;
20797 }
20798
20799
20800 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20801 PyObject *resultobj = 0;
20802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20803 int arg2 = (int) wxMOUSE_BTN_ANY ;
20804 bool result;
20805 void *argp1 = 0 ;
20806 int res1 = 0 ;
20807 int val2 ;
20808 int ecode2 = 0 ;
20809 PyObject * obj0 = 0 ;
20810 PyObject * obj1 = 0 ;
20811 char * kwnames[] = {
20812 (char *) "self",(char *) "but", NULL
20813 };
20814
20815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20819 }
20820 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20821 if (obj1) {
20822 ecode2 = SWIG_AsVal_int(obj1, &val2);
20823 if (!SWIG_IsOK(ecode2)) {
20824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20825 }
20826 arg2 = static_cast< int >(val2);
20827 }
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20831 wxPyEndAllowThreads(__tstate);
20832 if (PyErr_Occurred()) SWIG_fail;
20833 }
20834 {
20835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20836 }
20837 return resultobj;
20838 fail:
20839 return NULL;
20840 }
20841
20842
20843 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20844 PyObject *resultobj = 0;
20845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20846 int arg2 ;
20847 bool result;
20848 void *argp1 = 0 ;
20849 int res1 = 0 ;
20850 int val2 ;
20851 int ecode2 = 0 ;
20852 PyObject * obj0 = 0 ;
20853 PyObject * obj1 = 0 ;
20854 char * kwnames[] = {
20855 (char *) "self",(char *) "button", NULL
20856 };
20857
20858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20860 if (!SWIG_IsOK(res1)) {
20861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20862 }
20863 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20864 ecode2 = SWIG_AsVal_int(obj1, &val2);
20865 if (!SWIG_IsOK(ecode2)) {
20866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20867 }
20868 arg2 = static_cast< int >(val2);
20869 {
20870 PyThreadState* __tstate = wxPyBeginAllowThreads();
20871 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 {
20876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20877 }
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20885 PyObject *resultobj = 0;
20886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20887 int arg2 ;
20888 bool result;
20889 void *argp1 = 0 ;
20890 int res1 = 0 ;
20891 int val2 ;
20892 int ecode2 = 0 ;
20893 PyObject * obj0 = 0 ;
20894 PyObject * obj1 = 0 ;
20895 char * kwnames[] = {
20896 (char *) "self",(char *) "but", NULL
20897 };
20898
20899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20901 if (!SWIG_IsOK(res1)) {
20902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20903 }
20904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20905 ecode2 = SWIG_AsVal_int(obj1, &val2);
20906 if (!SWIG_IsOK(ecode2)) {
20907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20908 }
20909 arg2 = static_cast< int >(val2);
20910 {
20911 PyThreadState* __tstate = wxPyBeginAllowThreads();
20912 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
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_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20926 PyObject *resultobj = 0;
20927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20928 int 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_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20938 }
20939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_From_int(static_cast< int >(result));
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20956 bool result;
20957 void *argp1 = 0 ;
20958 int res1 = 0 ;
20959 PyObject *swig_obj[1] ;
20960
20961 if (!args) SWIG_fail;
20962 swig_obj[0] = args;
20963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20964 if (!SWIG_IsOK(res1)) {
20965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20966 }
20967 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20968 {
20969 PyThreadState* __tstate = wxPyBeginAllowThreads();
20970 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 {
20975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20976 }
20977 return resultobj;
20978 fail:
20979 return NULL;
20980 }
20981
20982
20983 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20984 PyObject *resultobj = 0;
20985 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20986 bool result;
20987 void *argp1 = 0 ;
20988 int res1 = 0 ;
20989 PyObject *swig_obj[1] ;
20990
20991 if (!args) SWIG_fail;
20992 swig_obj[0] = args;
20993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20994 if (!SWIG_IsOK(res1)) {
20995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20996 }
20997 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20998 {
20999 PyThreadState* __tstate = wxPyBeginAllowThreads();
21000 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
21001 wxPyEndAllowThreads(__tstate);
21002 if (PyErr_Occurred()) SWIG_fail;
21003 }
21004 {
21005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21006 }
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21014 PyObject *resultobj = 0;
21015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21016 bool result;
21017 void *argp1 = 0 ;
21018 int res1 = 0 ;
21019 PyObject *swig_obj[1] ;
21020
21021 if (!args) SWIG_fail;
21022 swig_obj[0] = args;
21023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21024 if (!SWIG_IsOK(res1)) {
21025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21026 }
21027 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 {
21035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21036 }
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21044 PyObject *resultobj = 0;
21045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21046 bool result;
21047 void *argp1 = 0 ;
21048 int res1 = 0 ;
21049 PyObject *swig_obj[1] ;
21050
21051 if (!args) SWIG_fail;
21052 swig_obj[0] = args;
21053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21054 if (!SWIG_IsOK(res1)) {
21055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21056 }
21057 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21058 {
21059 PyThreadState* __tstate = wxPyBeginAllowThreads();
21060 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21061 wxPyEndAllowThreads(__tstate);
21062 if (PyErr_Occurred()) SWIG_fail;
21063 }
21064 {
21065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21066 }
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21074 PyObject *resultobj = 0;
21075 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21076 bool result;
21077 void *argp1 = 0 ;
21078 int res1 = 0 ;
21079 PyObject *swig_obj[1] ;
21080
21081 if (!args) SWIG_fail;
21082 swig_obj[0] = args;
21083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21084 if (!SWIG_IsOK(res1)) {
21085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21086 }
21087 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21088 {
21089 PyThreadState* __tstate = wxPyBeginAllowThreads();
21090 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21091 wxPyEndAllowThreads(__tstate);
21092 if (PyErr_Occurred()) SWIG_fail;
21093 }
21094 {
21095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21096 }
21097 return resultobj;
21098 fail:
21099 return NULL;
21100 }
21101
21102
21103 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21104 PyObject *resultobj = 0;
21105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21106 bool result;
21107 void *argp1 = 0 ;
21108 int res1 = 0 ;
21109 PyObject *swig_obj[1] ;
21110
21111 if (!args) SWIG_fail;
21112 swig_obj[0] = args;
21113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21114 if (!SWIG_IsOK(res1)) {
21115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21116 }
21117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 {
21125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21126 }
21127 return resultobj;
21128 fail:
21129 return NULL;
21130 }
21131
21132
21133 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21134 PyObject *resultobj = 0;
21135 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21136 bool result;
21137 void *argp1 = 0 ;
21138 int res1 = 0 ;
21139 PyObject *swig_obj[1] ;
21140
21141 if (!args) SWIG_fail;
21142 swig_obj[0] = args;
21143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21144 if (!SWIG_IsOK(res1)) {
21145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21146 }
21147 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21148 {
21149 PyThreadState* __tstate = wxPyBeginAllowThreads();
21150 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 {
21155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21156 }
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21164 PyObject *resultobj = 0;
21165 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21166 bool result;
21167 void *argp1 = 0 ;
21168 int res1 = 0 ;
21169 PyObject *swig_obj[1] ;
21170
21171 if (!args) SWIG_fail;
21172 swig_obj[0] = args;
21173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21174 if (!SWIG_IsOK(res1)) {
21175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21176 }
21177 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21178 {
21179 PyThreadState* __tstate = wxPyBeginAllowThreads();
21180 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21181 wxPyEndAllowThreads(__tstate);
21182 if (PyErr_Occurred()) SWIG_fail;
21183 }
21184 {
21185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21186 }
21187 return resultobj;
21188 fail:
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21194 PyObject *resultobj = 0;
21195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21196 bool result;
21197 void *argp1 = 0 ;
21198 int res1 = 0 ;
21199 PyObject *swig_obj[1] ;
21200
21201 if (!args) SWIG_fail;
21202 swig_obj[0] = args;
21203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21204 if (!SWIG_IsOK(res1)) {
21205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21206 }
21207 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21208 {
21209 PyThreadState* __tstate = wxPyBeginAllowThreads();
21210 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21211 wxPyEndAllowThreads(__tstate);
21212 if (PyErr_Occurred()) SWIG_fail;
21213 }
21214 {
21215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21216 }
21217 return resultobj;
21218 fail:
21219 return NULL;
21220 }
21221
21222
21223 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21224 PyObject *resultobj = 0;
21225 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21226 bool result;
21227 void *argp1 = 0 ;
21228 int res1 = 0 ;
21229 PyObject *swig_obj[1] ;
21230
21231 if (!args) SWIG_fail;
21232 swig_obj[0] = args;
21233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21234 if (!SWIG_IsOK(res1)) {
21235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21236 }
21237 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21238 {
21239 PyThreadState* __tstate = wxPyBeginAllowThreads();
21240 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 {
21245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21246 }
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21254 PyObject *resultobj = 0;
21255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21256 bool result;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 PyObject *swig_obj[1] ;
21260
21261 if (!args) SWIG_fail;
21262 swig_obj[0] = args;
21263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21264 if (!SWIG_IsOK(res1)) {
21265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21266 }
21267 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21268 {
21269 PyThreadState* __tstate = wxPyBeginAllowThreads();
21270 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21271 wxPyEndAllowThreads(__tstate);
21272 if (PyErr_Occurred()) SWIG_fail;
21273 }
21274 {
21275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21276 }
21277 return resultobj;
21278 fail:
21279 return NULL;
21280 }
21281
21282
21283 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21284 PyObject *resultobj = 0;
21285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21286 bool result;
21287 void *argp1 = 0 ;
21288 int res1 = 0 ;
21289 PyObject *swig_obj[1] ;
21290
21291 if (!args) SWIG_fail;
21292 swig_obj[0] = args;
21293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21294 if (!SWIG_IsOK(res1)) {
21295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21296 }
21297 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21298 {
21299 PyThreadState* __tstate = wxPyBeginAllowThreads();
21300 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 {
21305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21306 }
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21314 PyObject *resultobj = 0;
21315 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21316 bool result;
21317 void *argp1 = 0 ;
21318 int res1 = 0 ;
21319 PyObject *swig_obj[1] ;
21320
21321 if (!args) SWIG_fail;
21322 swig_obj[0] = args;
21323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21324 if (!SWIG_IsOK(res1)) {
21325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21326 }
21327 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21328 {
21329 PyThreadState* __tstate = wxPyBeginAllowThreads();
21330 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21331 wxPyEndAllowThreads(__tstate);
21332 if (PyErr_Occurred()) SWIG_fail;
21333 }
21334 {
21335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21336 }
21337 return resultobj;
21338 fail:
21339 return NULL;
21340 }
21341
21342
21343 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21344 PyObject *resultobj = 0;
21345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21346 bool result;
21347 void *argp1 = 0 ;
21348 int res1 = 0 ;
21349 PyObject *swig_obj[1] ;
21350
21351 if (!args) SWIG_fail;
21352 swig_obj[0] = args;
21353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21356 }
21357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21358 {
21359 PyThreadState* __tstate = wxPyBeginAllowThreads();
21360 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21361 wxPyEndAllowThreads(__tstate);
21362 if (PyErr_Occurred()) SWIG_fail;
21363 }
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_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21374 PyObject *resultobj = 0;
21375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21376 bool result;
21377 void *argp1 = 0 ;
21378 int res1 = 0 ;
21379 PyObject *swig_obj[1] ;
21380
21381 if (!args) SWIG_fail;
21382 swig_obj[0] = args;
21383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21384 if (!SWIG_IsOK(res1)) {
21385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21386 }
21387 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21388 {
21389 PyThreadState* __tstate = wxPyBeginAllowThreads();
21390 result = (bool)(arg1)->LeftIsDown();
21391 wxPyEndAllowThreads(__tstate);
21392 if (PyErr_Occurred()) SWIG_fail;
21393 }
21394 {
21395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21396 }
21397 return resultobj;
21398 fail:
21399 return NULL;
21400 }
21401
21402
21403 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(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_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21416 }
21417 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 result = (bool)(arg1)->MiddleIsDown();
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 {
21425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21426 }
21427 return resultobj;
21428 fail:
21429 return NULL;
21430 }
21431
21432
21433 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21434 PyObject *resultobj = 0;
21435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21436 bool result;
21437 void *argp1 = 0 ;
21438 int res1 = 0 ;
21439 PyObject *swig_obj[1] ;
21440
21441 if (!args) SWIG_fail;
21442 swig_obj[0] = args;
21443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21444 if (!SWIG_IsOK(res1)) {
21445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21446 }
21447 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21448 {
21449 PyThreadState* __tstate = wxPyBeginAllowThreads();
21450 result = (bool)(arg1)->RightIsDown();
21451 wxPyEndAllowThreads(__tstate);
21452 if (PyErr_Occurred()) SWIG_fail;
21453 }
21454 {
21455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21456 }
21457 return resultobj;
21458 fail:
21459 return NULL;
21460 }
21461
21462
21463 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21464 PyObject *resultobj = 0;
21465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21466 bool result;
21467 void *argp1 = 0 ;
21468 int res1 = 0 ;
21469 PyObject *swig_obj[1] ;
21470
21471 if (!args) SWIG_fail;
21472 swig_obj[0] = args;
21473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21474 if (!SWIG_IsOK(res1)) {
21475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21476 }
21477 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21478 {
21479 PyThreadState* __tstate = wxPyBeginAllowThreads();
21480 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21481 wxPyEndAllowThreads(__tstate);
21482 if (PyErr_Occurred()) SWIG_fail;
21483 }
21484 {
21485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21486 }
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21494 PyObject *resultobj = 0;
21495 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21496 bool result;
21497 void *argp1 = 0 ;
21498 int res1 = 0 ;
21499 PyObject *swig_obj[1] ;
21500
21501 if (!args) SWIG_fail;
21502 swig_obj[0] = args;
21503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21504 if (!SWIG_IsOK(res1)) {
21505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21506 }
21507 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21511 wxPyEndAllowThreads(__tstate);
21512 if (PyErr_Occurred()) SWIG_fail;
21513 }
21514 {
21515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21516 }
21517 return resultobj;
21518 fail:
21519 return NULL;
21520 }
21521
21522
21523 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21524 PyObject *resultobj = 0;
21525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21526 bool result;
21527 void *argp1 = 0 ;
21528 int res1 = 0 ;
21529 PyObject *swig_obj[1] ;
21530
21531 if (!args) SWIG_fail;
21532 swig_obj[0] = args;
21533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21534 if (!SWIG_IsOK(res1)) {
21535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21536 }
21537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21538 {
21539 PyThreadState* __tstate = wxPyBeginAllowThreads();
21540 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21541 wxPyEndAllowThreads(__tstate);
21542 if (PyErr_Occurred()) SWIG_fail;
21543 }
21544 {
21545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21546 }
21547 return resultobj;
21548 fail:
21549 return NULL;
21550 }
21551
21552
21553 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21554 PyObject *resultobj = 0;
21555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21556 bool result;
21557 void *argp1 = 0 ;
21558 int res1 = 0 ;
21559 PyObject *swig_obj[1] ;
21560
21561 if (!args) SWIG_fail;
21562 swig_obj[0] = args;
21563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21564 if (!SWIG_IsOK(res1)) {
21565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21566 }
21567 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21568 {
21569 PyThreadState* __tstate = wxPyBeginAllowThreads();
21570 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21571 wxPyEndAllowThreads(__tstate);
21572 if (PyErr_Occurred()) SWIG_fail;
21573 }
21574 {
21575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21576 }
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21584 PyObject *resultobj = 0;
21585 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21586 wxPoint result;
21587 void *argp1 = 0 ;
21588 int res1 = 0 ;
21589 PyObject *swig_obj[1] ;
21590
21591 if (!args) SWIG_fail;
21592 swig_obj[0] = args;
21593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21594 if (!SWIG_IsOK(res1)) {
21595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21596 }
21597 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21598 {
21599 PyThreadState* __tstate = wxPyBeginAllowThreads();
21600 result = (arg1)->GetPosition();
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21612 PyObject *resultobj = 0;
21613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21614 long *arg2 = (long *) 0 ;
21615 long *arg3 = (long *) 0 ;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 long temp2 ;
21619 int res2 = SWIG_TMPOBJ ;
21620 long temp3 ;
21621 int res3 = SWIG_TMPOBJ ;
21622 PyObject *swig_obj[1] ;
21623
21624 arg2 = &temp2;
21625 arg3 = &temp3;
21626 if (!args) SWIG_fail;
21627 swig_obj[0] = args;
21628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21629 if (!SWIG_IsOK(res1)) {
21630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21631 }
21632 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21633 {
21634 PyThreadState* __tstate = wxPyBeginAllowThreads();
21635 (arg1)->GetPosition(arg2,arg3);
21636 wxPyEndAllowThreads(__tstate);
21637 if (PyErr_Occurred()) SWIG_fail;
21638 }
21639 resultobj = SWIG_Py_Void();
21640 if (SWIG_IsTmpObj(res2)) {
21641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21642 } else {
21643 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21645 }
21646 if (SWIG_IsTmpObj(res3)) {
21647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21648 } else {
21649 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21651 }
21652 return resultobj;
21653 fail:
21654 return NULL;
21655 }
21656
21657
21658 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21659 PyObject *resultobj = 0;
21660 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21661 wxDC *arg2 = 0 ;
21662 wxPoint result;
21663 void *argp1 = 0 ;
21664 int res1 = 0 ;
21665 void *argp2 = 0 ;
21666 int res2 = 0 ;
21667 PyObject * obj0 = 0 ;
21668 PyObject * obj1 = 0 ;
21669 char * kwnames[] = {
21670 (char *) "self",(char *) "dc", NULL
21671 };
21672
21673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21675 if (!SWIG_IsOK(res1)) {
21676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21677 }
21678 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21679 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21680 if (!SWIG_IsOK(res2)) {
21681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21682 }
21683 if (!argp2) {
21684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21685 }
21686 arg2 = reinterpret_cast< wxDC * >(argp2);
21687 {
21688 PyThreadState* __tstate = wxPyBeginAllowThreads();
21689 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21694 return resultobj;
21695 fail:
21696 return NULL;
21697 }
21698
21699
21700 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21701 PyObject *resultobj = 0;
21702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21703 int result;
21704 void *argp1 = 0 ;
21705 int res1 = 0 ;
21706 PyObject *swig_obj[1] ;
21707
21708 if (!args) SWIG_fail;
21709 swig_obj[0] = args;
21710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21711 if (!SWIG_IsOK(res1)) {
21712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21713 }
21714 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21715 {
21716 PyThreadState* __tstate = wxPyBeginAllowThreads();
21717 result = (int)((wxMouseEvent const *)arg1)->GetX();
21718 wxPyEndAllowThreads(__tstate);
21719 if (PyErr_Occurred()) SWIG_fail;
21720 }
21721 resultobj = SWIG_From_int(static_cast< int >(result));
21722 return resultobj;
21723 fail:
21724 return NULL;
21725 }
21726
21727
21728 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21729 PyObject *resultobj = 0;
21730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21731 int result;
21732 void *argp1 = 0 ;
21733 int res1 = 0 ;
21734 PyObject *swig_obj[1] ;
21735
21736 if (!args) SWIG_fail;
21737 swig_obj[0] = args;
21738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21739 if (!SWIG_IsOK(res1)) {
21740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21741 }
21742 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21743 {
21744 PyThreadState* __tstate = wxPyBeginAllowThreads();
21745 result = (int)((wxMouseEvent const *)arg1)->GetY();
21746 wxPyEndAllowThreads(__tstate);
21747 if (PyErr_Occurred()) SWIG_fail;
21748 }
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_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 PyObject *resultobj = 0;
21758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21759 int result;
21760 void *argp1 = 0 ;
21761 int res1 = 0 ;
21762 PyObject *swig_obj[1] ;
21763
21764 if (!args) SWIG_fail;
21765 swig_obj[0] = args;
21766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21767 if (!SWIG_IsOK(res1)) {
21768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21769 }
21770 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 resultobj = SWIG_From_int(static_cast< int >(result));
21778 return resultobj;
21779 fail:
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 PyObject *resultobj = 0;
21786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21787 int result;
21788 void *argp1 = 0 ;
21789 int res1 = 0 ;
21790 PyObject *swig_obj[1] ;
21791
21792 if (!args) SWIG_fail;
21793 swig_obj[0] = args;
21794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21795 if (!SWIG_IsOK(res1)) {
21796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21797 }
21798 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21799 {
21800 PyThreadState* __tstate = wxPyBeginAllowThreads();
21801 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 resultobj = SWIG_From_int(static_cast< int >(result));
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 PyObject *resultobj = 0;
21814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21815 int result;
21816 void *argp1 = 0 ;
21817 int res1 = 0 ;
21818 PyObject *swig_obj[1] ;
21819
21820 if (!args) SWIG_fail;
21821 swig_obj[0] = args;
21822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21823 if (!SWIG_IsOK(res1)) {
21824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21825 }
21826 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21827 {
21828 PyThreadState* __tstate = wxPyBeginAllowThreads();
21829 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21830 wxPyEndAllowThreads(__tstate);
21831 if (PyErr_Occurred()) SWIG_fail;
21832 }
21833 resultobj = SWIG_From_int(static_cast< int >(result));
21834 return resultobj;
21835 fail:
21836 return NULL;
21837 }
21838
21839
21840 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21841 PyObject *resultobj = 0;
21842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21843 bool result;
21844 void *argp1 = 0 ;
21845 int res1 = 0 ;
21846 PyObject *swig_obj[1] ;
21847
21848 if (!args) SWIG_fail;
21849 swig_obj[0] = args;
21850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21851 if (!SWIG_IsOK(res1)) {
21852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21853 }
21854 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21855 {
21856 PyThreadState* __tstate = wxPyBeginAllowThreads();
21857 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21858 wxPyEndAllowThreads(__tstate);
21859 if (PyErr_Occurred()) SWIG_fail;
21860 }
21861 {
21862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21863 }
21864 return resultobj;
21865 fail:
21866 return NULL;
21867 }
21868
21869
21870 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 PyObject *resultobj = 0;
21872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21873 int arg2 ;
21874 void *argp1 = 0 ;
21875 int res1 = 0 ;
21876 int val2 ;
21877 int ecode2 = 0 ;
21878 PyObject *swig_obj[2] ;
21879
21880 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21882 if (!SWIG_IsOK(res1)) {
21883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21884 }
21885 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21886 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21887 if (!SWIG_IsOK(ecode2)) {
21888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21889 }
21890 arg2 = static_cast< int >(val2);
21891 if (arg1) (arg1)->m_x = arg2;
21892
21893 resultobj = SWIG_Py_Void();
21894 return resultobj;
21895 fail:
21896 return NULL;
21897 }
21898
21899
21900 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 PyObject *resultobj = 0;
21902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21903 int result;
21904 void *argp1 = 0 ;
21905 int res1 = 0 ;
21906 PyObject *swig_obj[1] ;
21907
21908 if (!args) SWIG_fail;
21909 swig_obj[0] = args;
21910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21911 if (!SWIG_IsOK(res1)) {
21912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21913 }
21914 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21915 result = (int) ((arg1)->m_x);
21916 resultobj = SWIG_From_int(static_cast< int >(result));
21917 return resultobj;
21918 fail:
21919 return NULL;
21920 }
21921
21922
21923 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21924 PyObject *resultobj = 0;
21925 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21926 int arg2 ;
21927 void *argp1 = 0 ;
21928 int res1 = 0 ;
21929 int val2 ;
21930 int ecode2 = 0 ;
21931 PyObject *swig_obj[2] ;
21932
21933 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21935 if (!SWIG_IsOK(res1)) {
21936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21937 }
21938 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21939 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21940 if (!SWIG_IsOK(ecode2)) {
21941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21942 }
21943 arg2 = static_cast< int >(val2);
21944 if (arg1) (arg1)->m_y = arg2;
21945
21946 resultobj = SWIG_Py_Void();
21947 return resultobj;
21948 fail:
21949 return NULL;
21950 }
21951
21952
21953 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21954 PyObject *resultobj = 0;
21955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21956 int result;
21957 void *argp1 = 0 ;
21958 int res1 = 0 ;
21959 PyObject *swig_obj[1] ;
21960
21961 if (!args) SWIG_fail;
21962 swig_obj[0] = args;
21963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21964 if (!SWIG_IsOK(res1)) {
21965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21966 }
21967 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21968 result = (int) ((arg1)->m_y);
21969 resultobj = SWIG_From_int(static_cast< int >(result));
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21977 PyObject *resultobj = 0;
21978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21979 bool arg2 ;
21980 void *argp1 = 0 ;
21981 int res1 = 0 ;
21982 bool val2 ;
21983 int ecode2 = 0 ;
21984 PyObject *swig_obj[2] ;
21985
21986 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21988 if (!SWIG_IsOK(res1)) {
21989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21990 }
21991 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21992 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21993 if (!SWIG_IsOK(ecode2)) {
21994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21995 }
21996 arg2 = static_cast< bool >(val2);
21997 if (arg1) (arg1)->m_leftDown = arg2;
21998
21999 resultobj = SWIG_Py_Void();
22000 return resultobj;
22001 fail:
22002 return NULL;
22003 }
22004
22005
22006 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22007 PyObject *resultobj = 0;
22008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22009 bool result;
22010 void *argp1 = 0 ;
22011 int res1 = 0 ;
22012 PyObject *swig_obj[1] ;
22013
22014 if (!args) SWIG_fail;
22015 swig_obj[0] = args;
22016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22017 if (!SWIG_IsOK(res1)) {
22018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22019 }
22020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22021 result = (bool) ((arg1)->m_leftDown);
22022 {
22023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22024 }
22025 return resultobj;
22026 fail:
22027 return NULL;
22028 }
22029
22030
22031 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22032 PyObject *resultobj = 0;
22033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22034 bool arg2 ;
22035 void *argp1 = 0 ;
22036 int res1 = 0 ;
22037 bool val2 ;
22038 int ecode2 = 0 ;
22039 PyObject *swig_obj[2] ;
22040
22041 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22045 }
22046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22047 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22048 if (!SWIG_IsOK(ecode2)) {
22049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22050 }
22051 arg2 = static_cast< bool >(val2);
22052 if (arg1) (arg1)->m_middleDown = arg2;
22053
22054 resultobj = SWIG_Py_Void();
22055 return resultobj;
22056 fail:
22057 return NULL;
22058 }
22059
22060
22061 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22062 PyObject *resultobj = 0;
22063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22064 bool result;
22065 void *argp1 = 0 ;
22066 int res1 = 0 ;
22067 PyObject *swig_obj[1] ;
22068
22069 if (!args) SWIG_fail;
22070 swig_obj[0] = args;
22071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22072 if (!SWIG_IsOK(res1)) {
22073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22074 }
22075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22076 result = (bool) ((arg1)->m_middleDown);
22077 {
22078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22079 }
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22087 PyObject *resultobj = 0;
22088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22089 bool arg2 ;
22090 void *argp1 = 0 ;
22091 int res1 = 0 ;
22092 bool val2 ;
22093 int ecode2 = 0 ;
22094 PyObject *swig_obj[2] ;
22095
22096 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22098 if (!SWIG_IsOK(res1)) {
22099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22100 }
22101 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22102 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22103 if (!SWIG_IsOK(ecode2)) {
22104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22105 }
22106 arg2 = static_cast< bool >(val2);
22107 if (arg1) (arg1)->m_rightDown = arg2;
22108
22109 resultobj = SWIG_Py_Void();
22110 return resultobj;
22111 fail:
22112 return NULL;
22113 }
22114
22115
22116 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22117 PyObject *resultobj = 0;
22118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22119 bool result;
22120 void *argp1 = 0 ;
22121 int res1 = 0 ;
22122 PyObject *swig_obj[1] ;
22123
22124 if (!args) SWIG_fail;
22125 swig_obj[0] = args;
22126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22127 if (!SWIG_IsOK(res1)) {
22128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22129 }
22130 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22131 result = (bool) ((arg1)->m_rightDown);
22132 {
22133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22134 }
22135 return resultobj;
22136 fail:
22137 return NULL;
22138 }
22139
22140
22141 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22142 PyObject *resultobj = 0;
22143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22144 bool arg2 ;
22145 void *argp1 = 0 ;
22146 int res1 = 0 ;
22147 bool val2 ;
22148 int ecode2 = 0 ;
22149 PyObject *swig_obj[2] ;
22150
22151 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22153 if (!SWIG_IsOK(res1)) {
22154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22155 }
22156 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22157 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22158 if (!SWIG_IsOK(ecode2)) {
22159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22160 }
22161 arg2 = static_cast< bool >(val2);
22162 if (arg1) (arg1)->m_controlDown = arg2;
22163
22164 resultobj = SWIG_Py_Void();
22165 return resultobj;
22166 fail:
22167 return NULL;
22168 }
22169
22170
22171 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22172 PyObject *resultobj = 0;
22173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22174 bool result;
22175 void *argp1 = 0 ;
22176 int res1 = 0 ;
22177 PyObject *swig_obj[1] ;
22178
22179 if (!args) SWIG_fail;
22180 swig_obj[0] = args;
22181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22182 if (!SWIG_IsOK(res1)) {
22183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22184 }
22185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22186 result = (bool) ((arg1)->m_controlDown);
22187 {
22188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22189 }
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22197 PyObject *resultobj = 0;
22198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22199 bool arg2 ;
22200 void *argp1 = 0 ;
22201 int res1 = 0 ;
22202 bool val2 ;
22203 int ecode2 = 0 ;
22204 PyObject *swig_obj[2] ;
22205
22206 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22208 if (!SWIG_IsOK(res1)) {
22209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22210 }
22211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22212 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22213 if (!SWIG_IsOK(ecode2)) {
22214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22215 }
22216 arg2 = static_cast< bool >(val2);
22217 if (arg1) (arg1)->m_shiftDown = arg2;
22218
22219 resultobj = SWIG_Py_Void();
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22227 PyObject *resultobj = 0;
22228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22229 bool result;
22230 void *argp1 = 0 ;
22231 int res1 = 0 ;
22232 PyObject *swig_obj[1] ;
22233
22234 if (!args) SWIG_fail;
22235 swig_obj[0] = args;
22236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22237 if (!SWIG_IsOK(res1)) {
22238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22239 }
22240 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22241 result = (bool) ((arg1)->m_shiftDown);
22242 {
22243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22244 }
22245 return resultobj;
22246 fail:
22247 return NULL;
22248 }
22249
22250
22251 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22252 PyObject *resultobj = 0;
22253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22254 bool arg2 ;
22255 void *argp1 = 0 ;
22256 int res1 = 0 ;
22257 bool val2 ;
22258 int ecode2 = 0 ;
22259 PyObject *swig_obj[2] ;
22260
22261 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22263 if (!SWIG_IsOK(res1)) {
22264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22265 }
22266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22267 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22268 if (!SWIG_IsOK(ecode2)) {
22269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22270 }
22271 arg2 = static_cast< bool >(val2);
22272 if (arg1) (arg1)->m_altDown = arg2;
22273
22274 resultobj = SWIG_Py_Void();
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22284 bool result;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 PyObject *swig_obj[1] ;
22288
22289 if (!args) SWIG_fail;
22290 swig_obj[0] = args;
22291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22292 if (!SWIG_IsOK(res1)) {
22293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22294 }
22295 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22296 result = (bool) ((arg1)->m_altDown);
22297 {
22298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22299 }
22300 return resultobj;
22301 fail:
22302 return NULL;
22303 }
22304
22305
22306 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22307 PyObject *resultobj = 0;
22308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22309 bool arg2 ;
22310 void *argp1 = 0 ;
22311 int res1 = 0 ;
22312 bool val2 ;
22313 int ecode2 = 0 ;
22314 PyObject *swig_obj[2] ;
22315
22316 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22318 if (!SWIG_IsOK(res1)) {
22319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22320 }
22321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22322 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22323 if (!SWIG_IsOK(ecode2)) {
22324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22325 }
22326 arg2 = static_cast< bool >(val2);
22327 if (arg1) (arg1)->m_metaDown = arg2;
22328
22329 resultobj = SWIG_Py_Void();
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22337 PyObject *resultobj = 0;
22338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22339 bool result;
22340 void *argp1 = 0 ;
22341 int res1 = 0 ;
22342 PyObject *swig_obj[1] ;
22343
22344 if (!args) SWIG_fail;
22345 swig_obj[0] = args;
22346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22347 if (!SWIG_IsOK(res1)) {
22348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22349 }
22350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22351 result = (bool) ((arg1)->m_metaDown);
22352 {
22353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22354 }
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22362 PyObject *resultobj = 0;
22363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22364 int arg2 ;
22365 void *argp1 = 0 ;
22366 int res1 = 0 ;
22367 int val2 ;
22368 int ecode2 = 0 ;
22369 PyObject *swig_obj[2] ;
22370
22371 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22373 if (!SWIG_IsOK(res1)) {
22374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22375 }
22376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22377 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22378 if (!SWIG_IsOK(ecode2)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22380 }
22381 arg2 = static_cast< int >(val2);
22382 if (arg1) (arg1)->m_wheelRotation = arg2;
22383
22384 resultobj = SWIG_Py_Void();
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22392 PyObject *resultobj = 0;
22393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22394 int result;
22395 void *argp1 = 0 ;
22396 int res1 = 0 ;
22397 PyObject *swig_obj[1] ;
22398
22399 if (!args) SWIG_fail;
22400 swig_obj[0] = args;
22401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22402 if (!SWIG_IsOK(res1)) {
22403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22404 }
22405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22406 result = (int) ((arg1)->m_wheelRotation);
22407 resultobj = SWIG_From_int(static_cast< int >(result));
22408 return resultobj;
22409 fail:
22410 return NULL;
22411 }
22412
22413
22414 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22415 PyObject *resultobj = 0;
22416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22417 int arg2 ;
22418 void *argp1 = 0 ;
22419 int res1 = 0 ;
22420 int val2 ;
22421 int ecode2 = 0 ;
22422 PyObject *swig_obj[2] ;
22423
22424 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22426 if (!SWIG_IsOK(res1)) {
22427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22428 }
22429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22430 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22431 if (!SWIG_IsOK(ecode2)) {
22432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22433 }
22434 arg2 = static_cast< int >(val2);
22435 if (arg1) (arg1)->m_wheelDelta = arg2;
22436
22437 resultobj = SWIG_Py_Void();
22438 return resultobj;
22439 fail:
22440 return NULL;
22441 }
22442
22443
22444 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22445 PyObject *resultobj = 0;
22446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22447 int result;
22448 void *argp1 = 0 ;
22449 int res1 = 0 ;
22450 PyObject *swig_obj[1] ;
22451
22452 if (!args) SWIG_fail;
22453 swig_obj[0] = args;
22454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22455 if (!SWIG_IsOK(res1)) {
22456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22457 }
22458 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22459 result = (int) ((arg1)->m_wheelDelta);
22460 resultobj = SWIG_From_int(static_cast< int >(result));
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468 PyObject *resultobj = 0;
22469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22470 int arg2 ;
22471 void *argp1 = 0 ;
22472 int res1 = 0 ;
22473 int val2 ;
22474 int ecode2 = 0 ;
22475 PyObject *swig_obj[2] ;
22476
22477 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22479 if (!SWIG_IsOK(res1)) {
22480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22481 }
22482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22484 if (!SWIG_IsOK(ecode2)) {
22485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22486 }
22487 arg2 = static_cast< int >(val2);
22488 if (arg1) (arg1)->m_linesPerAction = arg2;
22489
22490 resultobj = SWIG_Py_Void();
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22500 int result;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 PyObject *swig_obj[1] ;
22504
22505 if (!args) SWIG_fail;
22506 swig_obj[0] = args;
22507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22508 if (!SWIG_IsOK(res1)) {
22509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22510 }
22511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22512 result = (int) ((arg1)->m_linesPerAction);
22513 resultobj = SWIG_From_int(static_cast< int >(result));
22514 return resultobj;
22515 fail:
22516 return NULL;
22517 }
22518
22519
22520 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22521 PyObject *obj;
22522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22523 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22524 return SWIG_Py_Void();
22525 }
22526
22527 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 return SWIG_Python_InitShadowInstance(args);
22529 }
22530
22531 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22532 PyObject *resultobj = 0;
22533 int arg1 = (int) 0 ;
22534 int arg2 = (int) 0 ;
22535 wxSetCursorEvent *result = 0 ;
22536 int val1 ;
22537 int ecode1 = 0 ;
22538 int val2 ;
22539 int ecode2 = 0 ;
22540 PyObject * obj0 = 0 ;
22541 PyObject * obj1 = 0 ;
22542 char * kwnames[] = {
22543 (char *) "x",(char *) "y", NULL
22544 };
22545
22546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22547 if (obj0) {
22548 ecode1 = SWIG_AsVal_int(obj0, &val1);
22549 if (!SWIG_IsOK(ecode1)) {
22550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22551 }
22552 arg1 = static_cast< int >(val1);
22553 }
22554 if (obj1) {
22555 ecode2 = SWIG_AsVal_int(obj1, &val2);
22556 if (!SWIG_IsOK(ecode2)) {
22557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22558 }
22559 arg2 = static_cast< int >(val2);
22560 }
22561 {
22562 PyThreadState* __tstate = wxPyBeginAllowThreads();
22563 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22564 wxPyEndAllowThreads(__tstate);
22565 if (PyErr_Occurred()) SWIG_fail;
22566 }
22567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22568 return resultobj;
22569 fail:
22570 return NULL;
22571 }
22572
22573
22574 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22575 PyObject *resultobj = 0;
22576 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22577 int result;
22578 void *argp1 = 0 ;
22579 int res1 = 0 ;
22580 PyObject *swig_obj[1] ;
22581
22582 if (!args) SWIG_fail;
22583 swig_obj[0] = args;
22584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22585 if (!SWIG_IsOK(res1)) {
22586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22587 }
22588 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22589 {
22590 PyThreadState* __tstate = wxPyBeginAllowThreads();
22591 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22592 wxPyEndAllowThreads(__tstate);
22593 if (PyErr_Occurred()) SWIG_fail;
22594 }
22595 resultobj = SWIG_From_int(static_cast< int >(result));
22596 return resultobj;
22597 fail:
22598 return NULL;
22599 }
22600
22601
22602 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22603 PyObject *resultobj = 0;
22604 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22605 int result;
22606 void *argp1 = 0 ;
22607 int res1 = 0 ;
22608 PyObject *swig_obj[1] ;
22609
22610 if (!args) SWIG_fail;
22611 swig_obj[0] = args;
22612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22613 if (!SWIG_IsOK(res1)) {
22614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22615 }
22616 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22617 {
22618 PyThreadState* __tstate = wxPyBeginAllowThreads();
22619 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22620 wxPyEndAllowThreads(__tstate);
22621 if (PyErr_Occurred()) SWIG_fail;
22622 }
22623 resultobj = SWIG_From_int(static_cast< int >(result));
22624 return resultobj;
22625 fail:
22626 return NULL;
22627 }
22628
22629
22630 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22631 PyObject *resultobj = 0;
22632 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22633 wxCursor *arg2 = 0 ;
22634 void *argp1 = 0 ;
22635 int res1 = 0 ;
22636 void *argp2 = 0 ;
22637 int res2 = 0 ;
22638 PyObject * obj0 = 0 ;
22639 PyObject * obj1 = 0 ;
22640 char * kwnames[] = {
22641 (char *) "self",(char *) "cursor", NULL
22642 };
22643
22644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22646 if (!SWIG_IsOK(res1)) {
22647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22648 }
22649 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22650 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22651 if (!SWIG_IsOK(res2)) {
22652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22653 }
22654 if (!argp2) {
22655 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22656 }
22657 arg2 = reinterpret_cast< wxCursor * >(argp2);
22658 {
22659 PyThreadState* __tstate = wxPyBeginAllowThreads();
22660 (arg1)->SetCursor((wxCursor const &)*arg2);
22661 wxPyEndAllowThreads(__tstate);
22662 if (PyErr_Occurred()) SWIG_fail;
22663 }
22664 resultobj = SWIG_Py_Void();
22665 return resultobj;
22666 fail:
22667 return NULL;
22668 }
22669
22670
22671 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22672 PyObject *resultobj = 0;
22673 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22674 wxCursor *result = 0 ;
22675 void *argp1 = 0 ;
22676 int res1 = 0 ;
22677 PyObject *swig_obj[1] ;
22678
22679 if (!args) SWIG_fail;
22680 swig_obj[0] = args;
22681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22682 if (!SWIG_IsOK(res1)) {
22683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22684 }
22685 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22686 {
22687 PyThreadState* __tstate = wxPyBeginAllowThreads();
22688 {
22689 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22690 result = (wxCursor *) &_result_ref;
22691 }
22692 wxPyEndAllowThreads(__tstate);
22693 if (PyErr_Occurred()) SWIG_fail;
22694 }
22695 {
22696 wxCursor* resultptr = new wxCursor(*result);
22697 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22698 }
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22706 PyObject *resultobj = 0;
22707 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22708 bool result;
22709 void *argp1 = 0 ;
22710 int res1 = 0 ;
22711 PyObject *swig_obj[1] ;
22712
22713 if (!args) SWIG_fail;
22714 swig_obj[0] = args;
22715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22716 if (!SWIG_IsOK(res1)) {
22717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22718 }
22719 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22720 {
22721 PyThreadState* __tstate = wxPyBeginAllowThreads();
22722 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22723 wxPyEndAllowThreads(__tstate);
22724 if (PyErr_Occurred()) SWIG_fail;
22725 }
22726 {
22727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22728 }
22729 return resultobj;
22730 fail:
22731 return NULL;
22732 }
22733
22734
22735 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22736 PyObject *obj;
22737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22738 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22739 return SWIG_Py_Void();
22740 }
22741
22742 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22743 return SWIG_Python_InitShadowInstance(args);
22744 }
22745
22746 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22747 PyObject *resultobj = 0;
22748 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22749 wxKeyEvent *result = 0 ;
22750 int val1 ;
22751 int ecode1 = 0 ;
22752 PyObject * obj0 = 0 ;
22753 char * kwnames[] = {
22754 (char *) "eventType", NULL
22755 };
22756
22757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22758 if (obj0) {
22759 ecode1 = SWIG_AsVal_int(obj0, &val1);
22760 if (!SWIG_IsOK(ecode1)) {
22761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22762 }
22763 arg1 = static_cast< wxEventType >(val1);
22764 }
22765 {
22766 PyThreadState* __tstate = wxPyBeginAllowThreads();
22767 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22768 wxPyEndAllowThreads(__tstate);
22769 if (PyErr_Occurred()) SWIG_fail;
22770 }
22771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22772 return resultobj;
22773 fail:
22774 return NULL;
22775 }
22776
22777
22778 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22779 PyObject *resultobj = 0;
22780 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22781 int result;
22782 void *argp1 = 0 ;
22783 int res1 = 0 ;
22784 PyObject *swig_obj[1] ;
22785
22786 if (!args) SWIG_fail;
22787 swig_obj[0] = args;
22788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22789 if (!SWIG_IsOK(res1)) {
22790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22791 }
22792 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22793 {
22794 PyThreadState* __tstate = wxPyBeginAllowThreads();
22795 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22796 wxPyEndAllowThreads(__tstate);
22797 if (PyErr_Occurred()) SWIG_fail;
22798 }
22799 resultobj = SWIG_From_int(static_cast< int >(result));
22800 return resultobj;
22801 fail:
22802 return NULL;
22803 }
22804
22805
22806 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22807 PyObject *resultobj = 0;
22808 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22809 bool result;
22810 void *argp1 = 0 ;
22811 int res1 = 0 ;
22812 PyObject *swig_obj[1] ;
22813
22814 if (!args) SWIG_fail;
22815 swig_obj[0] = args;
22816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22817 if (!SWIG_IsOK(res1)) {
22818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22819 }
22820 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22821 {
22822 PyThreadState* __tstate = wxPyBeginAllowThreads();
22823 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22824 wxPyEndAllowThreads(__tstate);
22825 if (PyErr_Occurred()) SWIG_fail;
22826 }
22827 {
22828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22829 }
22830 return resultobj;
22831 fail:
22832 return NULL;
22833 }
22834
22835
22836 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22837 PyObject *resultobj = 0;
22838 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22839 bool result;
22840 void *argp1 = 0 ;
22841 int res1 = 0 ;
22842 PyObject *swig_obj[1] ;
22843
22844 if (!args) SWIG_fail;
22845 swig_obj[0] = args;
22846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22847 if (!SWIG_IsOK(res1)) {
22848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22849 }
22850 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22851 {
22852 PyThreadState* __tstate = wxPyBeginAllowThreads();
22853 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 {
22858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22859 }
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22867 PyObject *resultobj = 0;
22868 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22869 bool result;
22870 void *argp1 = 0 ;
22871 int res1 = 0 ;
22872 PyObject *swig_obj[1] ;
22873
22874 if (!args) SWIG_fail;
22875 swig_obj[0] = args;
22876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22877 if (!SWIG_IsOK(res1)) {
22878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22879 }
22880 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22897 PyObject *resultobj = 0;
22898 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22899 bool result;
22900 void *argp1 = 0 ;
22901 int res1 = 0 ;
22902 PyObject *swig_obj[1] ;
22903
22904 if (!args) SWIG_fail;
22905 swig_obj[0] = args;
22906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22907 if (!SWIG_IsOK(res1)) {
22908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22909 }
22910 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22911 {
22912 PyThreadState* __tstate = wxPyBeginAllowThreads();
22913 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22914 wxPyEndAllowThreads(__tstate);
22915 if (PyErr_Occurred()) SWIG_fail;
22916 }
22917 {
22918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22919 }
22920 return resultobj;
22921 fail:
22922 return NULL;
22923 }
22924
22925
22926 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22927 PyObject *resultobj = 0;
22928 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22929 bool result;
22930 void *argp1 = 0 ;
22931 int res1 = 0 ;
22932 PyObject *swig_obj[1] ;
22933
22934 if (!args) SWIG_fail;
22935 swig_obj[0] = args;
22936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22937 if (!SWIG_IsOK(res1)) {
22938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22939 }
22940 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22944 wxPyEndAllowThreads(__tstate);
22945 if (PyErr_Occurred()) SWIG_fail;
22946 }
22947 {
22948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22949 }
22950 return resultobj;
22951 fail:
22952 return NULL;
22953 }
22954
22955
22956 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22957 PyObject *resultobj = 0;
22958 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22959 bool result;
22960 void *argp1 = 0 ;
22961 int res1 = 0 ;
22962 PyObject *swig_obj[1] ;
22963
22964 if (!args) SWIG_fail;
22965 swig_obj[0] = args;
22966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22967 if (!SWIG_IsOK(res1)) {
22968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22969 }
22970 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 {
22978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22979 }
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22987 PyObject *resultobj = 0;
22988 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22989 int result;
22990 void *argp1 = 0 ;
22991 int res1 = 0 ;
22992 PyObject *swig_obj[1] ;
22993
22994 if (!args) SWIG_fail;
22995 swig_obj[0] = args;
22996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22997 if (!SWIG_IsOK(res1)) {
22998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22999 }
23000 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23001 {
23002 PyThreadState* __tstate = wxPyBeginAllowThreads();
23003 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
23004 wxPyEndAllowThreads(__tstate);
23005 if (PyErr_Occurred()) SWIG_fail;
23006 }
23007 resultobj = SWIG_From_int(static_cast< int >(result));
23008 return resultobj;
23009 fail:
23010 return NULL;
23011 }
23012
23013
23014 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23015 PyObject *resultobj = 0;
23016 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23017 int result;
23018 void *argp1 = 0 ;
23019 int res1 = 0 ;
23020 PyObject *swig_obj[1] ;
23021
23022 if (!args) SWIG_fail;
23023 swig_obj[0] = args;
23024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23025 if (!SWIG_IsOK(res1)) {
23026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23027 }
23028 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23029 {
23030 PyThreadState* __tstate = wxPyBeginAllowThreads();
23031 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23032 wxPyEndAllowThreads(__tstate);
23033 if (PyErr_Occurred()) SWIG_fail;
23034 }
23035 resultobj = SWIG_From_int(static_cast< int >(result));
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23043 PyObject *resultobj = 0;
23044 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23045 int arg2 ;
23046 void *argp1 = 0 ;
23047 int res1 = 0 ;
23048 int val2 ;
23049 int ecode2 = 0 ;
23050 PyObject * obj0 = 0 ;
23051 PyObject * obj1 = 0 ;
23052 char * kwnames[] = {
23053 (char *) "self",(char *) "uniChar", NULL
23054 };
23055
23056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23058 if (!SWIG_IsOK(res1)) {
23059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23060 }
23061 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23062 ecode2 = SWIG_AsVal_int(obj1, &val2);
23063 if (!SWIG_IsOK(ecode2)) {
23064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23065 }
23066 arg2 = static_cast< int >(val2);
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23070 wxPyEndAllowThreads(__tstate);
23071 if (PyErr_Occurred()) SWIG_fail;
23072 }
23073 resultobj = SWIG_Py_Void();
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *resultobj = 0;
23082 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23083 unsigned int result;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 PyObject *swig_obj[1] ;
23087
23088 if (!args) SWIG_fail;
23089 swig_obj[0] = args;
23090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23093 }
23094 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23111 unsigned int result;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 PyObject *swig_obj[1] ;
23115
23116 if (!args) SWIG_fail;
23117 swig_obj[0] = args;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23121 }
23122 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23137 PyObject *resultobj = 0;
23138 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23139 wxPoint result;
23140 void *argp1 = 0 ;
23141 int res1 = 0 ;
23142 PyObject *swig_obj[1] ;
23143
23144 if (!args) SWIG_fail;
23145 swig_obj[0] = args;
23146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23147 if (!SWIG_IsOK(res1)) {
23148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23149 }
23150 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23151 {
23152 PyThreadState* __tstate = wxPyBeginAllowThreads();
23153 result = (arg1)->GetPosition();
23154 wxPyEndAllowThreads(__tstate);
23155 if (PyErr_Occurred()) SWIG_fail;
23156 }
23157 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23158 return resultobj;
23159 fail:
23160 return NULL;
23161 }
23162
23163
23164 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23165 PyObject *resultobj = 0;
23166 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23167 long *arg2 = (long *) 0 ;
23168 long *arg3 = (long *) 0 ;
23169 void *argp1 = 0 ;
23170 int res1 = 0 ;
23171 long temp2 ;
23172 int res2 = SWIG_TMPOBJ ;
23173 long temp3 ;
23174 int res3 = SWIG_TMPOBJ ;
23175 PyObject *swig_obj[1] ;
23176
23177 arg2 = &temp2;
23178 arg3 = &temp3;
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23184 }
23185 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 (arg1)->GetPosition(arg2,arg3);
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 resultobj = SWIG_Py_Void();
23193 if (SWIG_IsTmpObj(res2)) {
23194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23195 } else {
23196 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23198 }
23199 if (SWIG_IsTmpObj(res3)) {
23200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23201 } else {
23202 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23204 }
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23212 PyObject *resultobj = 0;
23213 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23214 int result;
23215 void *argp1 = 0 ;
23216 int res1 = 0 ;
23217 PyObject *swig_obj[1] ;
23218
23219 if (!args) SWIG_fail;
23220 swig_obj[0] = args;
23221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23222 if (!SWIG_IsOK(res1)) {
23223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23224 }
23225 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (int)((wxKeyEvent const *)arg1)->GetX();
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 resultobj = SWIG_From_int(static_cast< int >(result));
23233 return resultobj;
23234 fail:
23235 return NULL;
23236 }
23237
23238
23239 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23240 PyObject *resultobj = 0;
23241 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23242 int result;
23243 void *argp1 = 0 ;
23244 int res1 = 0 ;
23245 PyObject *swig_obj[1] ;
23246
23247 if (!args) SWIG_fail;
23248 swig_obj[0] = args;
23249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23250 if (!SWIG_IsOK(res1)) {
23251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23252 }
23253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23254 {
23255 PyThreadState* __tstate = wxPyBeginAllowThreads();
23256 result = (int)((wxKeyEvent const *)arg1)->GetY();
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 resultobj = SWIG_From_int(static_cast< int >(result));
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 PyObject *resultobj = 0;
23269 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23270 int arg2 ;
23271 void *argp1 = 0 ;
23272 int res1 = 0 ;
23273 int val2 ;
23274 int ecode2 = 0 ;
23275 PyObject *swig_obj[2] ;
23276
23277 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23279 if (!SWIG_IsOK(res1)) {
23280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23281 }
23282 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23283 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23284 if (!SWIG_IsOK(ecode2)) {
23285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23286 }
23287 arg2 = static_cast< int >(val2);
23288 if (arg1) (arg1)->m_x = arg2;
23289
23290 resultobj = SWIG_Py_Void();
23291 return resultobj;
23292 fail:
23293 return NULL;
23294 }
23295
23296
23297 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23298 PyObject *resultobj = 0;
23299 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23300 int result;
23301 void *argp1 = 0 ;
23302 int res1 = 0 ;
23303 PyObject *swig_obj[1] ;
23304
23305 if (!args) SWIG_fail;
23306 swig_obj[0] = args;
23307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23308 if (!SWIG_IsOK(res1)) {
23309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23310 }
23311 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23312 result = (int) ((arg1)->m_x);
23313 resultobj = SWIG_From_int(static_cast< int >(result));
23314 return resultobj;
23315 fail:
23316 return NULL;
23317 }
23318
23319
23320 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23321 PyObject *resultobj = 0;
23322 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23323 int arg2 ;
23324 void *argp1 = 0 ;
23325 int res1 = 0 ;
23326 int val2 ;
23327 int ecode2 = 0 ;
23328 PyObject *swig_obj[2] ;
23329
23330 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23332 if (!SWIG_IsOK(res1)) {
23333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23334 }
23335 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23336 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23337 if (!SWIG_IsOK(ecode2)) {
23338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23339 }
23340 arg2 = static_cast< int >(val2);
23341 if (arg1) (arg1)->m_y = arg2;
23342
23343 resultobj = SWIG_Py_Void();
23344 return resultobj;
23345 fail:
23346 return NULL;
23347 }
23348
23349
23350 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23351 PyObject *resultobj = 0;
23352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23353 int result;
23354 void *argp1 = 0 ;
23355 int res1 = 0 ;
23356 PyObject *swig_obj[1] ;
23357
23358 if (!args) SWIG_fail;
23359 swig_obj[0] = args;
23360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23361 if (!SWIG_IsOK(res1)) {
23362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23363 }
23364 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23365 result = (int) ((arg1)->m_y);
23366 resultobj = SWIG_From_int(static_cast< int >(result));
23367 return resultobj;
23368 fail:
23369 return NULL;
23370 }
23371
23372
23373 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23374 PyObject *resultobj = 0;
23375 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23376 long arg2 ;
23377 void *argp1 = 0 ;
23378 int res1 = 0 ;
23379 long val2 ;
23380 int ecode2 = 0 ;
23381 PyObject *swig_obj[2] ;
23382
23383 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23385 if (!SWIG_IsOK(res1)) {
23386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23387 }
23388 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23389 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23390 if (!SWIG_IsOK(ecode2)) {
23391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23392 }
23393 arg2 = static_cast< long >(val2);
23394 if (arg1) (arg1)->m_keyCode = arg2;
23395
23396 resultobj = SWIG_Py_Void();
23397 return resultobj;
23398 fail:
23399 return NULL;
23400 }
23401
23402
23403 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23404 PyObject *resultobj = 0;
23405 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23406 long result;
23407 void *argp1 = 0 ;
23408 int res1 = 0 ;
23409 PyObject *swig_obj[1] ;
23410
23411 if (!args) SWIG_fail;
23412 swig_obj[0] = args;
23413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23414 if (!SWIG_IsOK(res1)) {
23415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23416 }
23417 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23418 result = (long) ((arg1)->m_keyCode);
23419 resultobj = SWIG_From_long(static_cast< long >(result));
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *resultobj = 0;
23428 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23429 bool arg2 ;
23430 void *argp1 = 0 ;
23431 int res1 = 0 ;
23432 bool val2 ;
23433 int ecode2 = 0 ;
23434 PyObject *swig_obj[2] ;
23435
23436 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23438 if (!SWIG_IsOK(res1)) {
23439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23440 }
23441 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23442 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23443 if (!SWIG_IsOK(ecode2)) {
23444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23445 }
23446 arg2 = static_cast< bool >(val2);
23447 if (arg1) (arg1)->m_controlDown = arg2;
23448
23449 resultobj = SWIG_Py_Void();
23450 return resultobj;
23451 fail:
23452 return NULL;
23453 }
23454
23455
23456 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 PyObject *resultobj = 0;
23458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23459 bool result;
23460 void *argp1 = 0 ;
23461 int res1 = 0 ;
23462 PyObject *swig_obj[1] ;
23463
23464 if (!args) SWIG_fail;
23465 swig_obj[0] = args;
23466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23467 if (!SWIG_IsOK(res1)) {
23468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23469 }
23470 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23471 result = (bool) ((arg1)->m_controlDown);
23472 {
23473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23474 }
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23482 PyObject *resultobj = 0;
23483 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23484 bool arg2 ;
23485 void *argp1 = 0 ;
23486 int res1 = 0 ;
23487 bool val2 ;
23488 int ecode2 = 0 ;
23489 PyObject *swig_obj[2] ;
23490
23491 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23493 if (!SWIG_IsOK(res1)) {
23494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23495 }
23496 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23497 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23498 if (!SWIG_IsOK(ecode2)) {
23499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23500 }
23501 arg2 = static_cast< bool >(val2);
23502 if (arg1) (arg1)->m_shiftDown = arg2;
23503
23504 resultobj = SWIG_Py_Void();
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23512 PyObject *resultobj = 0;
23513 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23514 bool result;
23515 void *argp1 = 0 ;
23516 int res1 = 0 ;
23517 PyObject *swig_obj[1] ;
23518
23519 if (!args) SWIG_fail;
23520 swig_obj[0] = args;
23521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23522 if (!SWIG_IsOK(res1)) {
23523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23524 }
23525 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23526 result = (bool) ((arg1)->m_shiftDown);
23527 {
23528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23529 }
23530 return resultobj;
23531 fail:
23532 return NULL;
23533 }
23534
23535
23536 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23537 PyObject *resultobj = 0;
23538 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23539 bool arg2 ;
23540 void *argp1 = 0 ;
23541 int res1 = 0 ;
23542 bool val2 ;
23543 int ecode2 = 0 ;
23544 PyObject *swig_obj[2] ;
23545
23546 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23548 if (!SWIG_IsOK(res1)) {
23549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23550 }
23551 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23552 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23553 if (!SWIG_IsOK(ecode2)) {
23554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23555 }
23556 arg2 = static_cast< bool >(val2);
23557 if (arg1) (arg1)->m_altDown = arg2;
23558
23559 resultobj = SWIG_Py_Void();
23560 return resultobj;
23561 fail:
23562 return NULL;
23563 }
23564
23565
23566 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23567 PyObject *resultobj = 0;
23568 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23569 bool result;
23570 void *argp1 = 0 ;
23571 int res1 = 0 ;
23572 PyObject *swig_obj[1] ;
23573
23574 if (!args) SWIG_fail;
23575 swig_obj[0] = args;
23576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23577 if (!SWIG_IsOK(res1)) {
23578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23579 }
23580 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23581 result = (bool) ((arg1)->m_altDown);
23582 {
23583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23584 }
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23594 bool arg2 ;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 bool val2 ;
23598 int ecode2 = 0 ;
23599 PyObject *swig_obj[2] ;
23600
23601 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23603 if (!SWIG_IsOK(res1)) {
23604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23605 }
23606 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23607 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23608 if (!SWIG_IsOK(ecode2)) {
23609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23610 }
23611 arg2 = static_cast< bool >(val2);
23612 if (arg1) (arg1)->m_metaDown = arg2;
23613
23614 resultobj = SWIG_Py_Void();
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *resultobj = 0;
23623 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23624 bool result;
23625 void *argp1 = 0 ;
23626 int res1 = 0 ;
23627 PyObject *swig_obj[1] ;
23628
23629 if (!args) SWIG_fail;
23630 swig_obj[0] = args;
23631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23632 if (!SWIG_IsOK(res1)) {
23633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23634 }
23635 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23636 result = (bool) ((arg1)->m_metaDown);
23637 {
23638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23639 }
23640 return resultobj;
23641 fail:
23642 return NULL;
23643 }
23644
23645
23646 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23647 PyObject *resultobj = 0;
23648 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23649 bool arg2 ;
23650 void *argp1 = 0 ;
23651 int res1 = 0 ;
23652 bool val2 ;
23653 int ecode2 = 0 ;
23654 PyObject *swig_obj[2] ;
23655
23656 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23658 if (!SWIG_IsOK(res1)) {
23659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23660 }
23661 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23662 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23663 if (!SWIG_IsOK(ecode2)) {
23664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23665 }
23666 arg2 = static_cast< bool >(val2);
23667 if (arg1) (arg1)->m_scanCode = arg2;
23668
23669 resultobj = SWIG_Py_Void();
23670 return resultobj;
23671 fail:
23672 return NULL;
23673 }
23674
23675
23676 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23677 PyObject *resultobj = 0;
23678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23679 bool result;
23680 void *argp1 = 0 ;
23681 int res1 = 0 ;
23682 PyObject *swig_obj[1] ;
23683
23684 if (!args) SWIG_fail;
23685 swig_obj[0] = args;
23686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23687 if (!SWIG_IsOK(res1)) {
23688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23689 }
23690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23691 result = (bool) ((arg1)->m_scanCode);
23692 {
23693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23694 }
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *resultobj = 0;
23703 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23704 unsigned int arg2 ;
23705 void *argp1 = 0 ;
23706 int res1 = 0 ;
23707 unsigned int val2 ;
23708 int ecode2 = 0 ;
23709 PyObject *swig_obj[2] ;
23710
23711 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23713 if (!SWIG_IsOK(res1)) {
23714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23715 }
23716 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23717 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23718 if (!SWIG_IsOK(ecode2)) {
23719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23720 }
23721 arg2 = static_cast< unsigned int >(val2);
23722 if (arg1) (arg1)->m_rawCode = arg2;
23723
23724 resultobj = SWIG_Py_Void();
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732 PyObject *resultobj = 0;
23733 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23734 unsigned int result;
23735 void *argp1 = 0 ;
23736 int res1 = 0 ;
23737 PyObject *swig_obj[1] ;
23738
23739 if (!args) SWIG_fail;
23740 swig_obj[0] = args;
23741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23742 if (!SWIG_IsOK(res1)) {
23743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23744 }
23745 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23746 result = (unsigned int) ((arg1)->m_rawCode);
23747 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23748 return resultobj;
23749 fail:
23750 return NULL;
23751 }
23752
23753
23754 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23755 PyObject *resultobj = 0;
23756 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23757 unsigned int arg2 ;
23758 void *argp1 = 0 ;
23759 int res1 = 0 ;
23760 unsigned int val2 ;
23761 int ecode2 = 0 ;
23762 PyObject *swig_obj[2] ;
23763
23764 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23766 if (!SWIG_IsOK(res1)) {
23767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23768 }
23769 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23770 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23771 if (!SWIG_IsOK(ecode2)) {
23772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23773 }
23774 arg2 = static_cast< unsigned int >(val2);
23775 if (arg1) (arg1)->m_rawFlags = arg2;
23776
23777 resultobj = SWIG_Py_Void();
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23785 PyObject *resultobj = 0;
23786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23787 unsigned int result;
23788 void *argp1 = 0 ;
23789 int res1 = 0 ;
23790 PyObject *swig_obj[1] ;
23791
23792 if (!args) SWIG_fail;
23793 swig_obj[0] = args;
23794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23795 if (!SWIG_IsOK(res1)) {
23796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23797 }
23798 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23799 result = (unsigned int) ((arg1)->m_rawFlags);
23800 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23801 return resultobj;
23802 fail:
23803 return NULL;
23804 }
23805
23806
23807 SWIGINTERN PyObject *KeyEvent_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_wxKeyEvent, SWIG_NewClientData(obj));
23811 return SWIG_Py_Void();
23812 }
23813
23814 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23815 return SWIG_Python_InitShadowInstance(args);
23816 }
23817
23818 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj = 0;
23820 wxSize const &arg1_defvalue = wxDefaultSize ;
23821 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23822 int arg2 = (int) 0 ;
23823 wxSizeEvent *result = 0 ;
23824 wxSize temp1 ;
23825 int val2 ;
23826 int ecode2 = 0 ;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829 char * kwnames[] = {
23830 (char *) "sz",(char *) "winid", NULL
23831 };
23832
23833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23834 if (obj0) {
23835 {
23836 arg1 = &temp1;
23837 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23838 }
23839 }
23840 if (obj1) {
23841 ecode2 = SWIG_AsVal_int(obj1, &val2);
23842 if (!SWIG_IsOK(ecode2)) {
23843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23844 }
23845 arg2 = static_cast< int >(val2);
23846 }
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23850 wxPyEndAllowThreads(__tstate);
23851 if (PyErr_Occurred()) SWIG_fail;
23852 }
23853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23854 return resultobj;
23855 fail:
23856 return NULL;
23857 }
23858
23859
23860 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23861 PyObject *resultobj = 0;
23862 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23863 wxSize result;
23864 void *argp1 = 0 ;
23865 int res1 = 0 ;
23866 PyObject *swig_obj[1] ;
23867
23868 if (!args) SWIG_fail;
23869 swig_obj[0] = args;
23870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23871 if (!SWIG_IsOK(res1)) {
23872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23873 }
23874 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23875 {
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 result = ((wxSizeEvent const *)arg1)->GetSize();
23878 wxPyEndAllowThreads(__tstate);
23879 if (PyErr_Occurred()) SWIG_fail;
23880 }
23881 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23889 PyObject *resultobj = 0;
23890 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23891 wxRect result;
23892 void *argp1 = 0 ;
23893 int res1 = 0 ;
23894 PyObject *swig_obj[1] ;
23895
23896 if (!args) SWIG_fail;
23897 swig_obj[0] = args;
23898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23899 if (!SWIG_IsOK(res1)) {
23900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23901 }
23902 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23903 {
23904 PyThreadState* __tstate = wxPyBeginAllowThreads();
23905 result = ((wxSizeEvent const *)arg1)->GetRect();
23906 wxPyEndAllowThreads(__tstate);
23907 if (PyErr_Occurred()) SWIG_fail;
23908 }
23909 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23910 return resultobj;
23911 fail:
23912 return NULL;
23913 }
23914
23915
23916 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23917 PyObject *resultobj = 0;
23918 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23919 wxRect arg2 ;
23920 void *argp1 = 0 ;
23921 int res1 = 0 ;
23922 void *argp2 ;
23923 int res2 = 0 ;
23924 PyObject * obj0 = 0 ;
23925 PyObject * obj1 = 0 ;
23926 char * kwnames[] = {
23927 (char *) "self",(char *) "rect", NULL
23928 };
23929
23930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23932 if (!SWIG_IsOK(res1)) {
23933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23934 }
23935 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23936 {
23937 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23938 if (!SWIG_IsOK(res2)) {
23939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23940 }
23941 if (!argp2) {
23942 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23943 } else {
23944 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23945 arg2 = *temp;
23946 if (SWIG_IsNewObj(res2)) delete temp;
23947 }
23948 }
23949 {
23950 PyThreadState* __tstate = wxPyBeginAllowThreads();
23951 (arg1)->SetRect(arg2);
23952 wxPyEndAllowThreads(__tstate);
23953 if (PyErr_Occurred()) SWIG_fail;
23954 }
23955 resultobj = SWIG_Py_Void();
23956 return resultobj;
23957 fail:
23958 return NULL;
23959 }
23960
23961
23962 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23963 PyObject *resultobj = 0;
23964 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23965 wxSize arg2 ;
23966 void *argp1 = 0 ;
23967 int res1 = 0 ;
23968 void *argp2 ;
23969 int res2 = 0 ;
23970 PyObject * obj0 = 0 ;
23971 PyObject * obj1 = 0 ;
23972 char * kwnames[] = {
23973 (char *) "self",(char *) "size", NULL
23974 };
23975
23976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23978 if (!SWIG_IsOK(res1)) {
23979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23980 }
23981 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23982 {
23983 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23984 if (!SWIG_IsOK(res2)) {
23985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23986 }
23987 if (!argp2) {
23988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23989 } else {
23990 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23991 arg2 = *temp;
23992 if (SWIG_IsNewObj(res2)) delete temp;
23993 }
23994 }
23995 {
23996 PyThreadState* __tstate = wxPyBeginAllowThreads();
23997 wxSizeEvent_SetSize(arg1,arg2);
23998 wxPyEndAllowThreads(__tstate);
23999 if (PyErr_Occurred()) SWIG_fail;
24000 }
24001 resultobj = SWIG_Py_Void();
24002 return resultobj;
24003 fail:
24004 return NULL;
24005 }
24006
24007
24008 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24009 PyObject *resultobj = 0;
24010 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24011 wxSize *arg2 = (wxSize *) 0 ;
24012 void *argp1 = 0 ;
24013 int res1 = 0 ;
24014 void *argp2 = 0 ;
24015 int res2 = 0 ;
24016 PyObject *swig_obj[2] ;
24017
24018 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24020 if (!SWIG_IsOK(res1)) {
24021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24022 }
24023 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24024 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24025 if (!SWIG_IsOK(res2)) {
24026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24027 }
24028 arg2 = reinterpret_cast< wxSize * >(argp2);
24029 if (arg1) (arg1)->m_size = *arg2;
24030
24031 resultobj = SWIG_Py_Void();
24032 return resultobj;
24033 fail:
24034 return NULL;
24035 }
24036
24037
24038 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24039 PyObject *resultobj = 0;
24040 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24041 wxSize *result = 0 ;
24042 void *argp1 = 0 ;
24043 int res1 = 0 ;
24044 PyObject *swig_obj[1] ;
24045
24046 if (!args) SWIG_fail;
24047 swig_obj[0] = args;
24048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24049 if (!SWIG_IsOK(res1)) {
24050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24051 }
24052 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24053 result = (wxSize *)& ((arg1)->m_size);
24054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24062 PyObject *resultobj = 0;
24063 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24064 wxRect *arg2 = (wxRect *) 0 ;
24065 void *argp1 = 0 ;
24066 int res1 = 0 ;
24067 void *argp2 = 0 ;
24068 int res2 = 0 ;
24069 PyObject *swig_obj[2] ;
24070
24071 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24073 if (!SWIG_IsOK(res1)) {
24074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24075 }
24076 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24077 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24078 if (!SWIG_IsOK(res2)) {
24079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24080 }
24081 arg2 = reinterpret_cast< wxRect * >(argp2);
24082 if (arg1) (arg1)->m_rect = *arg2;
24083
24084 resultobj = SWIG_Py_Void();
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24092 PyObject *resultobj = 0;
24093 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24094 wxRect *result = 0 ;
24095 void *argp1 = 0 ;
24096 int res1 = 0 ;
24097 PyObject *swig_obj[1] ;
24098
24099 if (!args) SWIG_fail;
24100 swig_obj[0] = args;
24101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24102 if (!SWIG_IsOK(res1)) {
24103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24104 }
24105 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24106 result = (wxRect *)& ((arg1)->m_rect);
24107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24115 PyObject *obj;
24116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24117 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24118 return SWIG_Py_Void();
24119 }
24120
24121 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24122 return SWIG_Python_InitShadowInstance(args);
24123 }
24124
24125 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24126 PyObject *resultobj = 0;
24127 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24128 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24129 int arg2 = (int) 0 ;
24130 wxMoveEvent *result = 0 ;
24131 wxPoint temp1 ;
24132 int val2 ;
24133 int ecode2 = 0 ;
24134 PyObject * obj0 = 0 ;
24135 PyObject * obj1 = 0 ;
24136 char * kwnames[] = {
24137 (char *) "pos",(char *) "winid", NULL
24138 };
24139
24140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24141 if (obj0) {
24142 {
24143 arg1 = &temp1;
24144 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24145 }
24146 }
24147 if (obj1) {
24148 ecode2 = SWIG_AsVal_int(obj1, &val2);
24149 if (!SWIG_IsOK(ecode2)) {
24150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24151 }
24152 arg2 = static_cast< int >(val2);
24153 }
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24161 return resultobj;
24162 fail:
24163 return NULL;
24164 }
24165
24166
24167 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24168 PyObject *resultobj = 0;
24169 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24170 wxPoint result;
24171 void *argp1 = 0 ;
24172 int res1 = 0 ;
24173 PyObject *swig_obj[1] ;
24174
24175 if (!args) SWIG_fail;
24176 swig_obj[0] = args;
24177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24178 if (!SWIG_IsOK(res1)) {
24179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24180 }
24181 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24182 {
24183 PyThreadState* __tstate = wxPyBeginAllowThreads();
24184 result = ((wxMoveEvent const *)arg1)->GetPosition();
24185 wxPyEndAllowThreads(__tstate);
24186 if (PyErr_Occurred()) SWIG_fail;
24187 }
24188 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24189 return resultobj;
24190 fail:
24191 return NULL;
24192 }
24193
24194
24195 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24196 PyObject *resultobj = 0;
24197 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24198 wxRect result;
24199 void *argp1 = 0 ;
24200 int res1 = 0 ;
24201 PyObject *swig_obj[1] ;
24202
24203 if (!args) SWIG_fail;
24204 swig_obj[0] = args;
24205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24206 if (!SWIG_IsOK(res1)) {
24207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24208 }
24209 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24210 {
24211 PyThreadState* __tstate = wxPyBeginAllowThreads();
24212 result = ((wxMoveEvent const *)arg1)->GetRect();
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj = 0;
24225 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24226 wxRect *arg2 = 0 ;
24227 void *argp1 = 0 ;
24228 int res1 = 0 ;
24229 wxRect temp2 ;
24230 PyObject * obj0 = 0 ;
24231 PyObject * obj1 = 0 ;
24232 char * kwnames[] = {
24233 (char *) "self",(char *) "rect", NULL
24234 };
24235
24236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24238 if (!SWIG_IsOK(res1)) {
24239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24240 }
24241 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24242 {
24243 arg2 = &temp2;
24244 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24245 }
24246 {
24247 PyThreadState* __tstate = wxPyBeginAllowThreads();
24248 (arg1)->SetRect((wxRect const &)*arg2);
24249 wxPyEndAllowThreads(__tstate);
24250 if (PyErr_Occurred()) SWIG_fail;
24251 }
24252 resultobj = SWIG_Py_Void();
24253 return resultobj;
24254 fail:
24255 return NULL;
24256 }
24257
24258
24259 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24260 PyObject *resultobj = 0;
24261 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24262 wxPoint *arg2 = 0 ;
24263 void *argp1 = 0 ;
24264 int res1 = 0 ;
24265 wxPoint temp2 ;
24266 PyObject * obj0 = 0 ;
24267 PyObject * obj1 = 0 ;
24268 char * kwnames[] = {
24269 (char *) "self",(char *) "pos", NULL
24270 };
24271
24272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24274 if (!SWIG_IsOK(res1)) {
24275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24276 }
24277 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24278 {
24279 arg2 = &temp2;
24280 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24281 }
24282 {
24283 PyThreadState* __tstate = wxPyBeginAllowThreads();
24284 (arg1)->SetPosition((wxPoint const &)*arg2);
24285 wxPyEndAllowThreads(__tstate);
24286 if (PyErr_Occurred()) SWIG_fail;
24287 }
24288 resultobj = SWIG_Py_Void();
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24296 PyObject *obj;
24297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24298 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24299 return SWIG_Py_Void();
24300 }
24301
24302 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24303 return SWIG_Python_InitShadowInstance(args);
24304 }
24305
24306 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24307 PyObject *resultobj = 0;
24308 int arg1 = (int) 0 ;
24309 wxPaintEvent *result = 0 ;
24310 int val1 ;
24311 int ecode1 = 0 ;
24312 PyObject * obj0 = 0 ;
24313 char * kwnames[] = {
24314 (char *) "Id", NULL
24315 };
24316
24317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24318 if (obj0) {
24319 ecode1 = SWIG_AsVal_int(obj0, &val1);
24320 if (!SWIG_IsOK(ecode1)) {
24321 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24322 }
24323 arg1 = static_cast< int >(val1);
24324 }
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24339 PyObject *obj;
24340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24341 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24342 return SWIG_Py_Void();
24343 }
24344
24345 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24346 return SWIG_Python_InitShadowInstance(args);
24347 }
24348
24349 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24350 PyObject *resultobj = 0;
24351 int arg1 = (int) 0 ;
24352 wxNcPaintEvent *result = 0 ;
24353 int val1 ;
24354 int ecode1 = 0 ;
24355 PyObject * obj0 = 0 ;
24356 char * kwnames[] = {
24357 (char *) "winid", NULL
24358 };
24359
24360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24361 if (obj0) {
24362 ecode1 = SWIG_AsVal_int(obj0, &val1);
24363 if (!SWIG_IsOK(ecode1)) {
24364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24365 }
24366 arg1 = static_cast< int >(val1);
24367 }
24368 {
24369 PyThreadState* __tstate = wxPyBeginAllowThreads();
24370 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24371 wxPyEndAllowThreads(__tstate);
24372 if (PyErr_Occurred()) SWIG_fail;
24373 }
24374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24375 return resultobj;
24376 fail:
24377 return NULL;
24378 }
24379
24380
24381 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24382 PyObject *obj;
24383 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24384 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24385 return SWIG_Py_Void();
24386 }
24387
24388 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24389 return SWIG_Python_InitShadowInstance(args);
24390 }
24391
24392 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24393 PyObject *resultobj = 0;
24394 int arg1 = (int) 0 ;
24395 wxDC *arg2 = (wxDC *) NULL ;
24396 wxEraseEvent *result = 0 ;
24397 int val1 ;
24398 int ecode1 = 0 ;
24399 void *argp2 = 0 ;
24400 int res2 = 0 ;
24401 PyObject * obj0 = 0 ;
24402 PyObject * obj1 = 0 ;
24403 char * kwnames[] = {
24404 (char *) "Id",(char *) "dc", NULL
24405 };
24406
24407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24408 if (obj0) {
24409 ecode1 = SWIG_AsVal_int(obj0, &val1);
24410 if (!SWIG_IsOK(ecode1)) {
24411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24412 }
24413 arg1 = static_cast< int >(val1);
24414 }
24415 if (obj1) {
24416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24417 if (!SWIG_IsOK(res2)) {
24418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24419 }
24420 arg2 = reinterpret_cast< wxDC * >(argp2);
24421 }
24422 {
24423 PyThreadState* __tstate = wxPyBeginAllowThreads();
24424 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24425 wxPyEndAllowThreads(__tstate);
24426 if (PyErr_Occurred()) SWIG_fail;
24427 }
24428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24429 return resultobj;
24430 fail:
24431 return NULL;
24432 }
24433
24434
24435 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24436 PyObject *resultobj = 0;
24437 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24438 wxDC *result = 0 ;
24439 void *argp1 = 0 ;
24440 int res1 = 0 ;
24441 PyObject *swig_obj[1] ;
24442
24443 if (!args) SWIG_fail;
24444 swig_obj[0] = args;
24445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24446 if (!SWIG_IsOK(res1)) {
24447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24448 }
24449 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24450 {
24451 PyThreadState* __tstate = wxPyBeginAllowThreads();
24452 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24453 wxPyEndAllowThreads(__tstate);
24454 if (PyErr_Occurred()) SWIG_fail;
24455 }
24456 {
24457 resultobj = wxPyMake_wxObject(result, (bool)0);
24458 }
24459 return resultobj;
24460 fail:
24461 return NULL;
24462 }
24463
24464
24465 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24466 PyObject *obj;
24467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24468 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24469 return SWIG_Py_Void();
24470 }
24471
24472 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24473 return SWIG_Python_InitShadowInstance(args);
24474 }
24475
24476 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj = 0;
24478 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24479 int arg2 = (int) 0 ;
24480 wxFocusEvent *result = 0 ;
24481 int val1 ;
24482 int ecode1 = 0 ;
24483 int val2 ;
24484 int ecode2 = 0 ;
24485 PyObject * obj0 = 0 ;
24486 PyObject * obj1 = 0 ;
24487 char * kwnames[] = {
24488 (char *) "type",(char *) "winid", NULL
24489 };
24490
24491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24492 if (obj0) {
24493 ecode1 = SWIG_AsVal_int(obj0, &val1);
24494 if (!SWIG_IsOK(ecode1)) {
24495 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24496 }
24497 arg1 = static_cast< wxEventType >(val1);
24498 }
24499 if (obj1) {
24500 ecode2 = SWIG_AsVal_int(obj1, &val2);
24501 if (!SWIG_IsOK(ecode2)) {
24502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24503 }
24504 arg2 = static_cast< int >(val2);
24505 }
24506 {
24507 PyThreadState* __tstate = wxPyBeginAllowThreads();
24508 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24509 wxPyEndAllowThreads(__tstate);
24510 if (PyErr_Occurred()) SWIG_fail;
24511 }
24512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24520 PyObject *resultobj = 0;
24521 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24522 wxWindow *result = 0 ;
24523 void *argp1 = 0 ;
24524 int res1 = 0 ;
24525 PyObject *swig_obj[1] ;
24526
24527 if (!args) SWIG_fail;
24528 swig_obj[0] = args;
24529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24530 if (!SWIG_IsOK(res1)) {
24531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24532 }
24533 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24534 {
24535 PyThreadState* __tstate = wxPyBeginAllowThreads();
24536 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24537 wxPyEndAllowThreads(__tstate);
24538 if (PyErr_Occurred()) SWIG_fail;
24539 }
24540 {
24541 resultobj = wxPyMake_wxObject(result, (bool)0);
24542 }
24543 return resultobj;
24544 fail:
24545 return NULL;
24546 }
24547
24548
24549 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj = 0;
24551 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24552 wxWindow *arg2 = (wxWindow *) 0 ;
24553 void *argp1 = 0 ;
24554 int res1 = 0 ;
24555 void *argp2 = 0 ;
24556 int res2 = 0 ;
24557 PyObject * obj0 = 0 ;
24558 PyObject * obj1 = 0 ;
24559 char * kwnames[] = {
24560 (char *) "self",(char *) "win", NULL
24561 };
24562
24563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24565 if (!SWIG_IsOK(res1)) {
24566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24567 }
24568 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24570 if (!SWIG_IsOK(res2)) {
24571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24572 }
24573 arg2 = reinterpret_cast< wxWindow * >(argp2);
24574 {
24575 PyThreadState* __tstate = wxPyBeginAllowThreads();
24576 (arg1)->SetWindow(arg2);
24577 wxPyEndAllowThreads(__tstate);
24578 if (PyErr_Occurred()) SWIG_fail;
24579 }
24580 resultobj = SWIG_Py_Void();
24581 return resultobj;
24582 fail:
24583 return NULL;
24584 }
24585
24586
24587 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24588 PyObject *obj;
24589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24590 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24591 return SWIG_Py_Void();
24592 }
24593
24594 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24595 return SWIG_Python_InitShadowInstance(args);
24596 }
24597
24598 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24599 PyObject *resultobj = 0;
24600 wxWindow *arg1 = (wxWindow *) NULL ;
24601 wxChildFocusEvent *result = 0 ;
24602 void *argp1 = 0 ;
24603 int res1 = 0 ;
24604 PyObject * obj0 = 0 ;
24605 char * kwnames[] = {
24606 (char *) "win", NULL
24607 };
24608
24609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24610 if (obj0) {
24611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24612 if (!SWIG_IsOK(res1)) {
24613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24614 }
24615 arg1 = reinterpret_cast< wxWindow * >(argp1);
24616 }
24617 {
24618 PyThreadState* __tstate = wxPyBeginAllowThreads();
24619 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *resultobj = 0;
24632 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24633 wxWindow *result = 0 ;
24634 void *argp1 = 0 ;
24635 int res1 = 0 ;
24636 PyObject *swig_obj[1] ;
24637
24638 if (!args) SWIG_fail;
24639 swig_obj[0] = args;
24640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24641 if (!SWIG_IsOK(res1)) {
24642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24643 }
24644 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 {
24652 resultobj = wxPyMake_wxObject(result, (bool)0);
24653 }
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24661 PyObject *obj;
24662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24663 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24664 return SWIG_Py_Void();
24665 }
24666
24667 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24668 return SWIG_Python_InitShadowInstance(args);
24669 }
24670
24671 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj = 0;
24673 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24674 bool arg2 = (bool) true ;
24675 int arg3 = (int) 0 ;
24676 wxActivateEvent *result = 0 ;
24677 int val1 ;
24678 int ecode1 = 0 ;
24679 bool val2 ;
24680 int ecode2 = 0 ;
24681 int val3 ;
24682 int ecode3 = 0 ;
24683 PyObject * obj0 = 0 ;
24684 PyObject * obj1 = 0 ;
24685 PyObject * obj2 = 0 ;
24686 char * kwnames[] = {
24687 (char *) "type",(char *) "active",(char *) "Id", NULL
24688 };
24689
24690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24691 if (obj0) {
24692 ecode1 = SWIG_AsVal_int(obj0, &val1);
24693 if (!SWIG_IsOK(ecode1)) {
24694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24695 }
24696 arg1 = static_cast< wxEventType >(val1);
24697 }
24698 if (obj1) {
24699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24700 if (!SWIG_IsOK(ecode2)) {
24701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24702 }
24703 arg2 = static_cast< bool >(val2);
24704 }
24705 if (obj2) {
24706 ecode3 = SWIG_AsVal_int(obj2, &val3);
24707 if (!SWIG_IsOK(ecode3)) {
24708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24709 }
24710 arg3 = static_cast< int >(val3);
24711 }
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24715 wxPyEndAllowThreads(__tstate);
24716 if (PyErr_Occurred()) SWIG_fail;
24717 }
24718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24726 PyObject *resultobj = 0;
24727 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24728 bool result;
24729 void *argp1 = 0 ;
24730 int res1 = 0 ;
24731 PyObject *swig_obj[1] ;
24732
24733 if (!args) SWIG_fail;
24734 swig_obj[0] = args;
24735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24736 if (!SWIG_IsOK(res1)) {
24737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24738 }
24739 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24740 {
24741 PyThreadState* __tstate = wxPyBeginAllowThreads();
24742 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 {
24747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24748 }
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24756 PyObject *obj;
24757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24758 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24759 return SWIG_Py_Void();
24760 }
24761
24762 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24763 return SWIG_Python_InitShadowInstance(args);
24764 }
24765
24766 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24767 PyObject *resultobj = 0;
24768 int arg1 = (int) 0 ;
24769 wxInitDialogEvent *result = 0 ;
24770 int val1 ;
24771 int ecode1 = 0 ;
24772 PyObject * obj0 = 0 ;
24773 char * kwnames[] = {
24774 (char *) "Id", NULL
24775 };
24776
24777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24778 if (obj0) {
24779 ecode1 = SWIG_AsVal_int(obj0, &val1);
24780 if (!SWIG_IsOK(ecode1)) {
24781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24782 }
24783 arg1 = static_cast< int >(val1);
24784 }
24785 {
24786 PyThreadState* __tstate = wxPyBeginAllowThreads();
24787 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24788 wxPyEndAllowThreads(__tstate);
24789 if (PyErr_Occurred()) SWIG_fail;
24790 }
24791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24792 return resultobj;
24793 fail:
24794 return NULL;
24795 }
24796
24797
24798 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24799 PyObject *obj;
24800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24801 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24802 return SWIG_Py_Void();
24803 }
24804
24805 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24806 return SWIG_Python_InitShadowInstance(args);
24807 }
24808
24809 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24810 PyObject *resultobj = 0;
24811 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24812 int arg2 = (int) 0 ;
24813 wxMenu *arg3 = (wxMenu *) NULL ;
24814 wxMenuEvent *result = 0 ;
24815 int val1 ;
24816 int ecode1 = 0 ;
24817 int val2 ;
24818 int ecode2 = 0 ;
24819 void *argp3 = 0 ;
24820 int res3 = 0 ;
24821 PyObject * obj0 = 0 ;
24822 PyObject * obj1 = 0 ;
24823 PyObject * obj2 = 0 ;
24824 char * kwnames[] = {
24825 (char *) "type",(char *) "winid",(char *) "menu", NULL
24826 };
24827
24828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24829 if (obj0) {
24830 ecode1 = SWIG_AsVal_int(obj0, &val1);
24831 if (!SWIG_IsOK(ecode1)) {
24832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24833 }
24834 arg1 = static_cast< wxEventType >(val1);
24835 }
24836 if (obj1) {
24837 ecode2 = SWIG_AsVal_int(obj1, &val2);
24838 if (!SWIG_IsOK(ecode2)) {
24839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24840 }
24841 arg2 = static_cast< int >(val2);
24842 }
24843 if (obj2) {
24844 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24845 if (!SWIG_IsOK(res3)) {
24846 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24847 }
24848 arg3 = reinterpret_cast< wxMenu * >(argp3);
24849 }
24850 {
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24864 PyObject *resultobj = 0;
24865 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24866 int result;
24867 void *argp1 = 0 ;
24868 int res1 = 0 ;
24869 PyObject *swig_obj[1] ;
24870
24871 if (!args) SWIG_fail;
24872 swig_obj[0] = args;
24873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24874 if (!SWIG_IsOK(res1)) {
24875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24876 }
24877 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24878 {
24879 PyThreadState* __tstate = wxPyBeginAllowThreads();
24880 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24881 wxPyEndAllowThreads(__tstate);
24882 if (PyErr_Occurred()) SWIG_fail;
24883 }
24884 resultobj = SWIG_From_int(static_cast< int >(result));
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24892 PyObject *resultobj = 0;
24893 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24894 bool result;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 PyObject *swig_obj[1] ;
24898
24899 if (!args) SWIG_fail;
24900 swig_obj[0] = args;
24901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24902 if (!SWIG_IsOK(res1)) {
24903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24904 }
24905 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24906 {
24907 PyThreadState* __tstate = wxPyBeginAllowThreads();
24908 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24909 wxPyEndAllowThreads(__tstate);
24910 if (PyErr_Occurred()) SWIG_fail;
24911 }
24912 {
24913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24914 }
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24922 PyObject *resultobj = 0;
24923 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24924 wxMenu *result = 0 ;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 PyObject *swig_obj[1] ;
24928
24929 if (!args) SWIG_fail;
24930 swig_obj[0] = args;
24931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24932 if (!SWIG_IsOK(res1)) {
24933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24934 }
24935 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24936 {
24937 PyThreadState* __tstate = wxPyBeginAllowThreads();
24938 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 {
24943 resultobj = wxPyMake_wxObject(result, (bool)0);
24944 }
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24952 PyObject *obj;
24953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24954 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24955 return SWIG_Py_Void();
24956 }
24957
24958 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24959 return SWIG_Python_InitShadowInstance(args);
24960 }
24961
24962 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24963 PyObject *resultobj = 0;
24964 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24965 int arg2 = (int) 0 ;
24966 wxCloseEvent *result = 0 ;
24967 int val1 ;
24968 int ecode1 = 0 ;
24969 int val2 ;
24970 int ecode2 = 0 ;
24971 PyObject * obj0 = 0 ;
24972 PyObject * obj1 = 0 ;
24973 char * kwnames[] = {
24974 (char *) "type",(char *) "winid", NULL
24975 };
24976
24977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24978 if (obj0) {
24979 ecode1 = SWIG_AsVal_int(obj0, &val1);
24980 if (!SWIG_IsOK(ecode1)) {
24981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24982 }
24983 arg1 = static_cast< wxEventType >(val1);
24984 }
24985 if (obj1) {
24986 ecode2 = SWIG_AsVal_int(obj1, &val2);
24987 if (!SWIG_IsOK(ecode2)) {
24988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24989 }
24990 arg2 = static_cast< int >(val2);
24991 }
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24999 return resultobj;
25000 fail:
25001 return NULL;
25002 }
25003
25004
25005 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25006 PyObject *resultobj = 0;
25007 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25008 bool arg2 ;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 bool val2 ;
25012 int ecode2 = 0 ;
25013 PyObject * obj0 = 0 ;
25014 PyObject * obj1 = 0 ;
25015 char * kwnames[] = {
25016 (char *) "self",(char *) "logOff", NULL
25017 };
25018
25019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25021 if (!SWIG_IsOK(res1)) {
25022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25023 }
25024 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25025 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25026 if (!SWIG_IsOK(ecode2)) {
25027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25028 }
25029 arg2 = static_cast< bool >(val2);
25030 {
25031 PyThreadState* __tstate = wxPyBeginAllowThreads();
25032 (arg1)->SetLoggingOff(arg2);
25033 wxPyEndAllowThreads(__tstate);
25034 if (PyErr_Occurred()) SWIG_fail;
25035 }
25036 resultobj = SWIG_Py_Void();
25037 return resultobj;
25038 fail:
25039 return NULL;
25040 }
25041
25042
25043 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25044 PyObject *resultobj = 0;
25045 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25046 bool result;
25047 void *argp1 = 0 ;
25048 int res1 = 0 ;
25049 PyObject *swig_obj[1] ;
25050
25051 if (!args) SWIG_fail;
25052 swig_obj[0] = args;
25053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25054 if (!SWIG_IsOK(res1)) {
25055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25056 }
25057 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 {
25065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25066 }
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25074 PyObject *resultobj = 0;
25075 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25076 bool arg2 = (bool) true ;
25077 void *argp1 = 0 ;
25078 int res1 = 0 ;
25079 bool val2 ;
25080 int ecode2 = 0 ;
25081 PyObject * obj0 = 0 ;
25082 PyObject * obj1 = 0 ;
25083 char * kwnames[] = {
25084 (char *) "self",(char *) "veto", NULL
25085 };
25086
25087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25089 if (!SWIG_IsOK(res1)) {
25090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25091 }
25092 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25093 if (obj1) {
25094 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25095 if (!SWIG_IsOK(ecode2)) {
25096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25097 }
25098 arg2 = static_cast< bool >(val2);
25099 }
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 (arg1)->Veto(arg2);
25103 wxPyEndAllowThreads(__tstate);
25104 if (PyErr_Occurred()) SWIG_fail;
25105 }
25106 resultobj = SWIG_Py_Void();
25107 return resultobj;
25108 fail:
25109 return NULL;
25110 }
25111
25112
25113 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25114 PyObject *resultobj = 0;
25115 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25116 bool result;
25117 void *argp1 = 0 ;
25118 int res1 = 0 ;
25119 PyObject *swig_obj[1] ;
25120
25121 if (!args) SWIG_fail;
25122 swig_obj[0] = args;
25123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25124 if (!SWIG_IsOK(res1)) {
25125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25126 }
25127 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25131 wxPyEndAllowThreads(__tstate);
25132 if (PyErr_Occurred()) SWIG_fail;
25133 }
25134 {
25135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25136 }
25137 return resultobj;
25138 fail:
25139 return NULL;
25140 }
25141
25142
25143 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25144 PyObject *resultobj = 0;
25145 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25146 bool arg2 ;
25147 void *argp1 = 0 ;
25148 int res1 = 0 ;
25149 bool val2 ;
25150 int ecode2 = 0 ;
25151 PyObject * obj0 = 0 ;
25152 PyObject * obj1 = 0 ;
25153 char * kwnames[] = {
25154 (char *) "self",(char *) "canVeto", NULL
25155 };
25156
25157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25159 if (!SWIG_IsOK(res1)) {
25160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25161 }
25162 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25163 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25164 if (!SWIG_IsOK(ecode2)) {
25165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25166 }
25167 arg2 = static_cast< bool >(val2);
25168 {
25169 PyThreadState* __tstate = wxPyBeginAllowThreads();
25170 (arg1)->SetCanVeto(arg2);
25171 wxPyEndAllowThreads(__tstate);
25172 if (PyErr_Occurred()) SWIG_fail;
25173 }
25174 resultobj = SWIG_Py_Void();
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25182 PyObject *resultobj = 0;
25183 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25184 bool result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 PyObject *swig_obj[1] ;
25188
25189 if (!args) SWIG_fail;
25190 swig_obj[0] = args;
25191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25192 if (!SWIG_IsOK(res1)) {
25193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25194 }
25195 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25199 wxPyEndAllowThreads(__tstate);
25200 if (PyErr_Occurred()) SWIG_fail;
25201 }
25202 {
25203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25204 }
25205 return resultobj;
25206 fail:
25207 return NULL;
25208 }
25209
25210
25211 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25212 PyObject *obj;
25213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25214 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25215 return SWIG_Py_Void();
25216 }
25217
25218 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25219 return SWIG_Python_InitShadowInstance(args);
25220 }
25221
25222 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25223 PyObject *resultobj = 0;
25224 int arg1 = (int) 0 ;
25225 bool arg2 = (bool) false ;
25226 wxShowEvent *result = 0 ;
25227 int val1 ;
25228 int ecode1 = 0 ;
25229 bool val2 ;
25230 int ecode2 = 0 ;
25231 PyObject * obj0 = 0 ;
25232 PyObject * obj1 = 0 ;
25233 char * kwnames[] = {
25234 (char *) "winid",(char *) "show", NULL
25235 };
25236
25237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25238 if (obj0) {
25239 ecode1 = SWIG_AsVal_int(obj0, &val1);
25240 if (!SWIG_IsOK(ecode1)) {
25241 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25242 }
25243 arg1 = static_cast< int >(val1);
25244 }
25245 if (obj1) {
25246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25247 if (!SWIG_IsOK(ecode2)) {
25248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25249 }
25250 arg2 = static_cast< bool >(val2);
25251 }
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25259 return resultobj;
25260 fail:
25261 return NULL;
25262 }
25263
25264
25265 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25266 PyObject *resultobj = 0;
25267 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25268 bool arg2 ;
25269 void *argp1 = 0 ;
25270 int res1 = 0 ;
25271 bool val2 ;
25272 int ecode2 = 0 ;
25273 PyObject * obj0 = 0 ;
25274 PyObject * obj1 = 0 ;
25275 char * kwnames[] = {
25276 (char *) "self",(char *) "show", NULL
25277 };
25278
25279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25281 if (!SWIG_IsOK(res1)) {
25282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25283 }
25284 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25285 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25286 if (!SWIG_IsOK(ecode2)) {
25287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25288 }
25289 arg2 = static_cast< bool >(val2);
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 (arg1)->SetShow(arg2);
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 resultobj = SWIG_Py_Void();
25297 return resultobj;
25298 fail:
25299 return NULL;
25300 }
25301
25302
25303 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25304 PyObject *resultobj = 0;
25305 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25306 bool result;
25307 void *argp1 = 0 ;
25308 int res1 = 0 ;
25309 PyObject *swig_obj[1] ;
25310
25311 if (!args) SWIG_fail;
25312 swig_obj[0] = args;
25313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25314 if (!SWIG_IsOK(res1)) {
25315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25316 }
25317 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 {
25325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25326 }
25327 return resultobj;
25328 fail:
25329 return NULL;
25330 }
25331
25332
25333 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25334 PyObject *obj;
25335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25336 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25337 return SWIG_Py_Void();
25338 }
25339
25340 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25341 return SWIG_Python_InitShadowInstance(args);
25342 }
25343
25344 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25345 PyObject *resultobj = 0;
25346 int arg1 = (int) 0 ;
25347 bool arg2 = (bool) true ;
25348 wxIconizeEvent *result = 0 ;
25349 int val1 ;
25350 int ecode1 = 0 ;
25351 bool val2 ;
25352 int ecode2 = 0 ;
25353 PyObject * obj0 = 0 ;
25354 PyObject * obj1 = 0 ;
25355 char * kwnames[] = {
25356 (char *) "id",(char *) "iconized", NULL
25357 };
25358
25359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25360 if (obj0) {
25361 ecode1 = SWIG_AsVal_int(obj0, &val1);
25362 if (!SWIG_IsOK(ecode1)) {
25363 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25364 }
25365 arg1 = static_cast< int >(val1);
25366 }
25367 if (obj1) {
25368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25369 if (!SWIG_IsOK(ecode2)) {
25370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25371 }
25372 arg2 = static_cast< bool >(val2);
25373 }
25374 {
25375 PyThreadState* __tstate = wxPyBeginAllowThreads();
25376 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25377 wxPyEndAllowThreads(__tstate);
25378 if (PyErr_Occurred()) SWIG_fail;
25379 }
25380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25381 return resultobj;
25382 fail:
25383 return NULL;
25384 }
25385
25386
25387 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25388 PyObject *resultobj = 0;
25389 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25390 bool result;
25391 void *argp1 = 0 ;
25392 int res1 = 0 ;
25393 PyObject *swig_obj[1] ;
25394
25395 if (!args) SWIG_fail;
25396 swig_obj[0] = args;
25397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25398 if (!SWIG_IsOK(res1)) {
25399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25400 }
25401 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25402 {
25403 PyThreadState* __tstate = wxPyBeginAllowThreads();
25404 result = (bool)(arg1)->Iconized();
25405 wxPyEndAllowThreads(__tstate);
25406 if (PyErr_Occurred()) SWIG_fail;
25407 }
25408 {
25409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25410 }
25411 return resultobj;
25412 fail:
25413 return NULL;
25414 }
25415
25416
25417 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25418 PyObject *obj;
25419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25420 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25421 return SWIG_Py_Void();
25422 }
25423
25424 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25425 return SWIG_Python_InitShadowInstance(args);
25426 }
25427
25428 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25429 PyObject *resultobj = 0;
25430 int arg1 = (int) 0 ;
25431 wxMaximizeEvent *result = 0 ;
25432 int val1 ;
25433 int ecode1 = 0 ;
25434 PyObject * obj0 = 0 ;
25435 char * kwnames[] = {
25436 (char *) "id", NULL
25437 };
25438
25439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25440 if (obj0) {
25441 ecode1 = SWIG_AsVal_int(obj0, &val1);
25442 if (!SWIG_IsOK(ecode1)) {
25443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25444 }
25445 arg1 = static_cast< int >(val1);
25446 }
25447 {
25448 PyThreadState* __tstate = wxPyBeginAllowThreads();
25449 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25450 wxPyEndAllowThreads(__tstate);
25451 if (PyErr_Occurred()) SWIG_fail;
25452 }
25453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25454 return resultobj;
25455 fail:
25456 return NULL;
25457 }
25458
25459
25460 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25461 PyObject *obj;
25462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25463 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25464 return SWIG_Py_Void();
25465 }
25466
25467 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25468 return SWIG_Python_InitShadowInstance(args);
25469 }
25470
25471 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 PyObject *resultobj = 0;
25473 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25474 wxPoint result;
25475 void *argp1 = 0 ;
25476 int res1 = 0 ;
25477 PyObject *swig_obj[1] ;
25478
25479 if (!args) SWIG_fail;
25480 swig_obj[0] = args;
25481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25482 if (!SWIG_IsOK(res1)) {
25483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25484 }
25485 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25486 {
25487 PyThreadState* __tstate = wxPyBeginAllowThreads();
25488 result = (arg1)->GetPosition();
25489 wxPyEndAllowThreads(__tstate);
25490 if (PyErr_Occurred()) SWIG_fail;
25491 }
25492 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25500 PyObject *resultobj = 0;
25501 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25502 int result;
25503 void *argp1 = 0 ;
25504 int res1 = 0 ;
25505 PyObject *swig_obj[1] ;
25506
25507 if (!args) SWIG_fail;
25508 swig_obj[0] = args;
25509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25510 if (!SWIG_IsOK(res1)) {
25511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25512 }
25513 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25514 {
25515 PyThreadState* __tstate = wxPyBeginAllowThreads();
25516 result = (int)(arg1)->GetNumberOfFiles();
25517 wxPyEndAllowThreads(__tstate);
25518 if (PyErr_Occurred()) SWIG_fail;
25519 }
25520 resultobj = SWIG_From_int(static_cast< int >(result));
25521 return resultobj;
25522 fail:
25523 return NULL;
25524 }
25525
25526
25527 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25528 PyObject *resultobj = 0;
25529 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25530 PyObject *result = 0 ;
25531 void *argp1 = 0 ;
25532 int res1 = 0 ;
25533 PyObject *swig_obj[1] ;
25534
25535 if (!args) SWIG_fail;
25536 swig_obj[0] = args;
25537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25538 if (!SWIG_IsOK(res1)) {
25539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25540 }
25541 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25542 {
25543 PyThreadState* __tstate = wxPyBeginAllowThreads();
25544 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 resultobj = result;
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25556 PyObject *obj;
25557 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25558 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25559 return SWIG_Py_Void();
25560 }
25561
25562 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25563 PyObject *resultobj = 0;
25564 int arg1 = (int) 0 ;
25565 wxUpdateUIEvent *result = 0 ;
25566 int val1 ;
25567 int ecode1 = 0 ;
25568 PyObject * obj0 = 0 ;
25569 char * kwnames[] = {
25570 (char *) "commandId", NULL
25571 };
25572
25573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25574 if (obj0) {
25575 ecode1 = SWIG_AsVal_int(obj0, &val1);
25576 if (!SWIG_IsOK(ecode1)) {
25577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25578 }
25579 arg1 = static_cast< int >(val1);
25580 }
25581 {
25582 PyThreadState* __tstate = wxPyBeginAllowThreads();
25583 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25584 wxPyEndAllowThreads(__tstate);
25585 if (PyErr_Occurred()) SWIG_fail;
25586 }
25587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25588 return resultobj;
25589 fail:
25590 return NULL;
25591 }
25592
25593
25594 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25595 PyObject *resultobj = 0;
25596 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25597 bool result;
25598 void *argp1 = 0 ;
25599 int res1 = 0 ;
25600 PyObject *swig_obj[1] ;
25601
25602 if (!args) SWIG_fail;
25603 swig_obj[0] = args;
25604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25607 }
25608 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25609 {
25610 PyThreadState* __tstate = wxPyBeginAllowThreads();
25611 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25612 wxPyEndAllowThreads(__tstate);
25613 if (PyErr_Occurred()) SWIG_fail;
25614 }
25615 {
25616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25617 }
25618 return resultobj;
25619 fail:
25620 return NULL;
25621 }
25622
25623
25624 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25625 PyObject *resultobj = 0;
25626 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25627 bool result;
25628 void *argp1 = 0 ;
25629 int res1 = 0 ;
25630 PyObject *swig_obj[1] ;
25631
25632 if (!args) SWIG_fail;
25633 swig_obj[0] = args;
25634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25635 if (!SWIG_IsOK(res1)) {
25636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25637 }
25638 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25639 {
25640 PyThreadState* __tstate = wxPyBeginAllowThreads();
25641 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25642 wxPyEndAllowThreads(__tstate);
25643 if (PyErr_Occurred()) SWIG_fail;
25644 }
25645 {
25646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25647 }
25648 return resultobj;
25649 fail:
25650 return NULL;
25651 }
25652
25653
25654 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25655 PyObject *resultobj = 0;
25656 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25657 bool result;
25658 void *argp1 = 0 ;
25659 int res1 = 0 ;
25660 PyObject *swig_obj[1] ;
25661
25662 if (!args) SWIG_fail;
25663 swig_obj[0] = args;
25664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25665 if (!SWIG_IsOK(res1)) {
25666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25667 }
25668 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25669 {
25670 PyThreadState* __tstate = wxPyBeginAllowThreads();
25671 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25672 wxPyEndAllowThreads(__tstate);
25673 if (PyErr_Occurred()) SWIG_fail;
25674 }
25675 {
25676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25677 }
25678 return resultobj;
25679 fail:
25680 return NULL;
25681 }
25682
25683
25684 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25685 PyObject *resultobj = 0;
25686 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25687 wxString result;
25688 void *argp1 = 0 ;
25689 int res1 = 0 ;
25690 PyObject *swig_obj[1] ;
25691
25692 if (!args) SWIG_fail;
25693 swig_obj[0] = args;
25694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25695 if (!SWIG_IsOK(res1)) {
25696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25697 }
25698 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25699 {
25700 PyThreadState* __tstate = wxPyBeginAllowThreads();
25701 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25702 wxPyEndAllowThreads(__tstate);
25703 if (PyErr_Occurred()) SWIG_fail;
25704 }
25705 {
25706 #if wxUSE_UNICODE
25707 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25708 #else
25709 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25710 #endif
25711 }
25712 return resultobj;
25713 fail:
25714 return NULL;
25715 }
25716
25717
25718 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25719 PyObject *resultobj = 0;
25720 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25721 bool result;
25722 void *argp1 = 0 ;
25723 int res1 = 0 ;
25724 PyObject *swig_obj[1] ;
25725
25726 if (!args) SWIG_fail;
25727 swig_obj[0] = args;
25728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25729 if (!SWIG_IsOK(res1)) {
25730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25731 }
25732 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25733 {
25734 PyThreadState* __tstate = wxPyBeginAllowThreads();
25735 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25736 wxPyEndAllowThreads(__tstate);
25737 if (PyErr_Occurred()) SWIG_fail;
25738 }
25739 {
25740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25741 }
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25749 PyObject *resultobj = 0;
25750 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25751 bool result;
25752 void *argp1 = 0 ;
25753 int res1 = 0 ;
25754 PyObject *swig_obj[1] ;
25755
25756 if (!args) SWIG_fail;
25757 swig_obj[0] = args;
25758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25759 if (!SWIG_IsOK(res1)) {
25760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25761 }
25762 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25763 {
25764 PyThreadState* __tstate = wxPyBeginAllowThreads();
25765 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25766 wxPyEndAllowThreads(__tstate);
25767 if (PyErr_Occurred()) SWIG_fail;
25768 }
25769 {
25770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25771 }
25772 return resultobj;
25773 fail:
25774 return NULL;
25775 }
25776
25777
25778 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25779 PyObject *resultobj = 0;
25780 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25781 bool result;
25782 void *argp1 = 0 ;
25783 int res1 = 0 ;
25784 PyObject *swig_obj[1] ;
25785
25786 if (!args) SWIG_fail;
25787 swig_obj[0] = args;
25788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25789 if (!SWIG_IsOK(res1)) {
25790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25791 }
25792 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25793 {
25794 PyThreadState* __tstate = wxPyBeginAllowThreads();
25795 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25796 wxPyEndAllowThreads(__tstate);
25797 if (PyErr_Occurred()) SWIG_fail;
25798 }
25799 {
25800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25801 }
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25809 PyObject *resultobj = 0;
25810 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25811 bool result;
25812 void *argp1 = 0 ;
25813 int res1 = 0 ;
25814 PyObject *swig_obj[1] ;
25815
25816 if (!args) SWIG_fail;
25817 swig_obj[0] = args;
25818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25819 if (!SWIG_IsOK(res1)) {
25820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25821 }
25822 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25823 {
25824 PyThreadState* __tstate = wxPyBeginAllowThreads();
25825 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25826 wxPyEndAllowThreads(__tstate);
25827 if (PyErr_Occurred()) SWIG_fail;
25828 }
25829 {
25830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25831 }
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25839 PyObject *resultobj = 0;
25840 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25841 bool arg2 ;
25842 void *argp1 = 0 ;
25843 int res1 = 0 ;
25844 bool val2 ;
25845 int ecode2 = 0 ;
25846 PyObject * obj0 = 0 ;
25847 PyObject * obj1 = 0 ;
25848 char * kwnames[] = {
25849 (char *) "self",(char *) "check", NULL
25850 };
25851
25852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25854 if (!SWIG_IsOK(res1)) {
25855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25856 }
25857 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25858 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25859 if (!SWIG_IsOK(ecode2)) {
25860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25861 }
25862 arg2 = static_cast< bool >(val2);
25863 {
25864 PyThreadState* __tstate = wxPyBeginAllowThreads();
25865 (arg1)->Check(arg2);
25866 wxPyEndAllowThreads(__tstate);
25867 if (PyErr_Occurred()) SWIG_fail;
25868 }
25869 resultobj = SWIG_Py_Void();
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj = 0;
25878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25879 bool arg2 ;
25880 void *argp1 = 0 ;
25881 int res1 = 0 ;
25882 bool val2 ;
25883 int ecode2 = 0 ;
25884 PyObject * obj0 = 0 ;
25885 PyObject * obj1 = 0 ;
25886 char * kwnames[] = {
25887 (char *) "self",(char *) "enable", NULL
25888 };
25889
25890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25892 if (!SWIG_IsOK(res1)) {
25893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25894 }
25895 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25896 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25897 if (!SWIG_IsOK(ecode2)) {
25898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25899 }
25900 arg2 = static_cast< bool >(val2);
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 (arg1)->Enable(arg2);
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 resultobj = SWIG_Py_Void();
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj = 0;
25916 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25917 bool arg2 ;
25918 void *argp1 = 0 ;
25919 int res1 = 0 ;
25920 bool val2 ;
25921 int ecode2 = 0 ;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 char * kwnames[] = {
25925 (char *) "self",(char *) "show", NULL
25926 };
25927
25928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25930 if (!SWIG_IsOK(res1)) {
25931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25932 }
25933 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25935 if (!SWIG_IsOK(ecode2)) {
25936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25937 }
25938 arg2 = static_cast< bool >(val2);
25939 {
25940 PyThreadState* __tstate = wxPyBeginAllowThreads();
25941 (arg1)->Show(arg2);
25942 wxPyEndAllowThreads(__tstate);
25943 if (PyErr_Occurred()) SWIG_fail;
25944 }
25945 resultobj = SWIG_Py_Void();
25946 return resultobj;
25947 fail:
25948 return NULL;
25949 }
25950
25951
25952 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25953 PyObject *resultobj = 0;
25954 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25955 wxString *arg2 = 0 ;
25956 void *argp1 = 0 ;
25957 int res1 = 0 ;
25958 bool temp2 = false ;
25959 PyObject * obj0 = 0 ;
25960 PyObject * obj1 = 0 ;
25961 char * kwnames[] = {
25962 (char *) "self",(char *) "text", NULL
25963 };
25964
25965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25969 }
25970 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25971 {
25972 arg2 = wxString_in_helper(obj1);
25973 if (arg2 == NULL) SWIG_fail;
25974 temp2 = true;
25975 }
25976 {
25977 PyThreadState* __tstate = wxPyBeginAllowThreads();
25978 (arg1)->SetText((wxString const &)*arg2);
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 resultobj = SWIG_Py_Void();
25983 {
25984 if (temp2)
25985 delete arg2;
25986 }
25987 return resultobj;
25988 fail:
25989 {
25990 if (temp2)
25991 delete arg2;
25992 }
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25998 PyObject *resultobj = 0;
25999 long arg1 ;
26000 long val1 ;
26001 int ecode1 = 0 ;
26002 PyObject * obj0 = 0 ;
26003 char * kwnames[] = {
26004 (char *) "updateInterval", NULL
26005 };
26006
26007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
26008 ecode1 = SWIG_AsVal_long(obj0, &val1);
26009 if (!SWIG_IsOK(ecode1)) {
26010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
26011 }
26012 arg1 = static_cast< long >(val1);
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 wxUpdateUIEvent::SetUpdateInterval(arg1);
26016 wxPyEndAllowThreads(__tstate);
26017 if (PyErr_Occurred()) SWIG_fail;
26018 }
26019 resultobj = SWIG_Py_Void();
26020 return resultobj;
26021 fail:
26022 return NULL;
26023 }
26024
26025
26026 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26027 PyObject *resultobj = 0;
26028 long result;
26029
26030 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_From_long(static_cast< long >(result));
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26045 PyObject *resultobj = 0;
26046 wxWindow *arg1 = (wxWindow *) 0 ;
26047 bool result;
26048 void *argp1 = 0 ;
26049 int res1 = 0 ;
26050 PyObject * obj0 = 0 ;
26051 char * kwnames[] = {
26052 (char *) "win", NULL
26053 };
26054
26055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26057 if (!SWIG_IsOK(res1)) {
26058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26059 }
26060 arg1 = reinterpret_cast< wxWindow * >(argp1);
26061 {
26062 PyThreadState* __tstate = wxPyBeginAllowThreads();
26063 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26064 wxPyEndAllowThreads(__tstate);
26065 if (PyErr_Occurred()) SWIG_fail;
26066 }
26067 {
26068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26069 }
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26077 PyObject *resultobj = 0;
26078
26079 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26080 {
26081 PyThreadState* __tstate = wxPyBeginAllowThreads();
26082 wxUpdateUIEvent::ResetUpdateTime();
26083 wxPyEndAllowThreads(__tstate);
26084 if (PyErr_Occurred()) SWIG_fail;
26085 }
26086 resultobj = SWIG_Py_Void();
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj = 0;
26095 wxUpdateUIMode arg1 ;
26096 int val1 ;
26097 int ecode1 = 0 ;
26098 PyObject * obj0 = 0 ;
26099 char * kwnames[] = {
26100 (char *) "mode", NULL
26101 };
26102
26103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26104 ecode1 = SWIG_AsVal_int(obj0, &val1);
26105 if (!SWIG_IsOK(ecode1)) {
26106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26107 }
26108 arg1 = static_cast< wxUpdateUIMode >(val1);
26109 {
26110 PyThreadState* __tstate = wxPyBeginAllowThreads();
26111 wxUpdateUIEvent::SetMode(arg1);
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_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26123 PyObject *resultobj = 0;
26124 wxUpdateUIMode result;
26125
26126 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26127 {
26128 PyThreadState* __tstate = wxPyBeginAllowThreads();
26129 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 resultobj = SWIG_From_int(static_cast< int >(result));
26134 return resultobj;
26135 fail:
26136 return NULL;
26137 }
26138
26139
26140 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26141 PyObject *obj;
26142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26143 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26144 return SWIG_Py_Void();
26145 }
26146
26147 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26148 return SWIG_Python_InitShadowInstance(args);
26149 }
26150
26151 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26152 PyObject *resultobj = 0;
26153 wxSysColourChangedEvent *result = 0 ;
26154
26155 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26156 {
26157 PyThreadState* __tstate = wxPyBeginAllowThreads();
26158 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26159 wxPyEndAllowThreads(__tstate);
26160 if (PyErr_Occurred()) SWIG_fail;
26161 }
26162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26163 return resultobj;
26164 fail:
26165 return NULL;
26166 }
26167
26168
26169 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26170 PyObject *obj;
26171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26172 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26173 return SWIG_Py_Void();
26174 }
26175
26176 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26177 return SWIG_Python_InitShadowInstance(args);
26178 }
26179
26180 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26181 PyObject *resultobj = 0;
26182 int arg1 = (int) 0 ;
26183 wxWindow *arg2 = (wxWindow *) NULL ;
26184 wxMouseCaptureChangedEvent *result = 0 ;
26185 int val1 ;
26186 int ecode1 = 0 ;
26187 void *argp2 = 0 ;
26188 int res2 = 0 ;
26189 PyObject * obj0 = 0 ;
26190 PyObject * obj1 = 0 ;
26191 char * kwnames[] = {
26192 (char *) "winid",(char *) "gainedCapture", NULL
26193 };
26194
26195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26196 if (obj0) {
26197 ecode1 = SWIG_AsVal_int(obj0, &val1);
26198 if (!SWIG_IsOK(ecode1)) {
26199 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26200 }
26201 arg1 = static_cast< int >(val1);
26202 }
26203 if (obj1) {
26204 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26205 if (!SWIG_IsOK(res2)) {
26206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26207 }
26208 arg2 = reinterpret_cast< wxWindow * >(argp2);
26209 }
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26213 wxPyEndAllowThreads(__tstate);
26214 if (PyErr_Occurred()) SWIG_fail;
26215 }
26216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26217 return resultobj;
26218 fail:
26219 return NULL;
26220 }
26221
26222
26223 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26224 PyObject *resultobj = 0;
26225 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26226 wxWindow *result = 0 ;
26227 void *argp1 = 0 ;
26228 int res1 = 0 ;
26229 PyObject *swig_obj[1] ;
26230
26231 if (!args) SWIG_fail;
26232 swig_obj[0] = args;
26233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26234 if (!SWIG_IsOK(res1)) {
26235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26236 }
26237 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 {
26245 resultobj = wxPyMake_wxObject(result, (bool)0);
26246 }
26247 return resultobj;
26248 fail:
26249 return NULL;
26250 }
26251
26252
26253 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26254 PyObject *obj;
26255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26256 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26257 return SWIG_Py_Void();
26258 }
26259
26260 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26261 return SWIG_Python_InitShadowInstance(args);
26262 }
26263
26264 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26265 PyObject *resultobj = 0;
26266 int arg1 = (int) 0 ;
26267 wxMouseCaptureLostEvent *result = 0 ;
26268 int val1 ;
26269 int ecode1 = 0 ;
26270 PyObject * obj0 = 0 ;
26271 char * kwnames[] = {
26272 (char *) "winid", NULL
26273 };
26274
26275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26276 if (obj0) {
26277 ecode1 = SWIG_AsVal_int(obj0, &val1);
26278 if (!SWIG_IsOK(ecode1)) {
26279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26280 }
26281 arg1 = static_cast< int >(val1);
26282 }
26283 {
26284 PyThreadState* __tstate = wxPyBeginAllowThreads();
26285 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26286 wxPyEndAllowThreads(__tstate);
26287 if (PyErr_Occurred()) SWIG_fail;
26288 }
26289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 PyObject *obj;
26298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26299 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26300 return SWIG_Py_Void();
26301 }
26302
26303 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26304 return SWIG_Python_InitShadowInstance(args);
26305 }
26306
26307 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26308 PyObject *resultobj = 0;
26309 wxDisplayChangedEvent *result = 0 ;
26310
26311 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26315 wxPyEndAllowThreads(__tstate);
26316 if (PyErr_Occurred()) SWIG_fail;
26317 }
26318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26326 PyObject *obj;
26327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26328 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26329 return SWIG_Py_Void();
26330 }
26331
26332 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26333 return SWIG_Python_InitShadowInstance(args);
26334 }
26335
26336 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26337 PyObject *resultobj = 0;
26338 int arg1 = (int) 0 ;
26339 wxPaletteChangedEvent *result = 0 ;
26340 int val1 ;
26341 int ecode1 = 0 ;
26342 PyObject * obj0 = 0 ;
26343 char * kwnames[] = {
26344 (char *) "id", NULL
26345 };
26346
26347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26348 if (obj0) {
26349 ecode1 = SWIG_AsVal_int(obj0, &val1);
26350 if (!SWIG_IsOK(ecode1)) {
26351 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26352 }
26353 arg1 = static_cast< int >(val1);
26354 }
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26362 return resultobj;
26363 fail:
26364 return NULL;
26365 }
26366
26367
26368 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26369 PyObject *resultobj = 0;
26370 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26371 wxWindow *arg2 = (wxWindow *) 0 ;
26372 void *argp1 = 0 ;
26373 int res1 = 0 ;
26374 void *argp2 = 0 ;
26375 int res2 = 0 ;
26376 PyObject * obj0 = 0 ;
26377 PyObject * obj1 = 0 ;
26378 char * kwnames[] = {
26379 (char *) "self",(char *) "win", NULL
26380 };
26381
26382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26384 if (!SWIG_IsOK(res1)) {
26385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26386 }
26387 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26389 if (!SWIG_IsOK(res2)) {
26390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26391 }
26392 arg2 = reinterpret_cast< wxWindow * >(argp2);
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 (arg1)->SetChangedWindow(arg2);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_Py_Void();
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *resultobj = 0;
26408 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26409 wxWindow *result = 0 ;
26410 void *argp1 = 0 ;
26411 int res1 = 0 ;
26412 PyObject *swig_obj[1] ;
26413
26414 if (!args) SWIG_fail;
26415 swig_obj[0] = args;
26416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26417 if (!SWIG_IsOK(res1)) {
26418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26419 }
26420 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26421 {
26422 PyThreadState* __tstate = wxPyBeginAllowThreads();
26423 result = (wxWindow *)(arg1)->GetChangedWindow();
26424 wxPyEndAllowThreads(__tstate);
26425 if (PyErr_Occurred()) SWIG_fail;
26426 }
26427 {
26428 resultobj = wxPyMake_wxObject(result, (bool)0);
26429 }
26430 return resultobj;
26431 fail:
26432 return NULL;
26433 }
26434
26435
26436 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26437 PyObject *obj;
26438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26439 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26440 return SWIG_Py_Void();
26441 }
26442
26443 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26444 return SWIG_Python_InitShadowInstance(args);
26445 }
26446
26447 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26448 PyObject *resultobj = 0;
26449 int arg1 = (int) 0 ;
26450 wxQueryNewPaletteEvent *result = 0 ;
26451 int val1 ;
26452 int ecode1 = 0 ;
26453 PyObject * obj0 = 0 ;
26454 char * kwnames[] = {
26455 (char *) "winid", NULL
26456 };
26457
26458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26459 if (obj0) {
26460 ecode1 = SWIG_AsVal_int(obj0, &val1);
26461 if (!SWIG_IsOK(ecode1)) {
26462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26463 }
26464 arg1 = static_cast< int >(val1);
26465 }
26466 {
26467 PyThreadState* __tstate = wxPyBeginAllowThreads();
26468 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26469 wxPyEndAllowThreads(__tstate);
26470 if (PyErr_Occurred()) SWIG_fail;
26471 }
26472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26473 return resultobj;
26474 fail:
26475 return NULL;
26476 }
26477
26478
26479 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26480 PyObject *resultobj = 0;
26481 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26482 bool arg2 ;
26483 void *argp1 = 0 ;
26484 int res1 = 0 ;
26485 bool val2 ;
26486 int ecode2 = 0 ;
26487 PyObject * obj0 = 0 ;
26488 PyObject * obj1 = 0 ;
26489 char * kwnames[] = {
26490 (char *) "self",(char *) "realized", NULL
26491 };
26492
26493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26495 if (!SWIG_IsOK(res1)) {
26496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26497 }
26498 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26500 if (!SWIG_IsOK(ecode2)) {
26501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26502 }
26503 arg2 = static_cast< bool >(val2);
26504 {
26505 PyThreadState* __tstate = wxPyBeginAllowThreads();
26506 (arg1)->SetPaletteRealized(arg2);
26507 wxPyEndAllowThreads(__tstate);
26508 if (PyErr_Occurred()) SWIG_fail;
26509 }
26510 resultobj = SWIG_Py_Void();
26511 return resultobj;
26512 fail:
26513 return NULL;
26514 }
26515
26516
26517 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26518 PyObject *resultobj = 0;
26519 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26520 bool result;
26521 void *argp1 = 0 ;
26522 int res1 = 0 ;
26523 PyObject *swig_obj[1] ;
26524
26525 if (!args) SWIG_fail;
26526 swig_obj[0] = args;
26527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26528 if (!SWIG_IsOK(res1)) {
26529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26530 }
26531 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 {
26539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26540 }
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *obj;
26549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26550 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26551 return SWIG_Py_Void();
26552 }
26553
26554 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26555 return SWIG_Python_InitShadowInstance(args);
26556 }
26557
26558 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26559 PyObject *resultobj = 0;
26560 wxNavigationKeyEvent *result = 0 ;
26561
26562 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26563 {
26564 PyThreadState* __tstate = wxPyBeginAllowThreads();
26565 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26570 return resultobj;
26571 fail:
26572 return NULL;
26573 }
26574
26575
26576 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26577 PyObject *resultobj = 0;
26578 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26579 bool result;
26580 void *argp1 = 0 ;
26581 int res1 = 0 ;
26582 PyObject *swig_obj[1] ;
26583
26584 if (!args) SWIG_fail;
26585 swig_obj[0] = args;
26586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26587 if (!SWIG_IsOK(res1)) {
26588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26589 }
26590 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 {
26598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26599 }
26600 return resultobj;
26601 fail:
26602 return NULL;
26603 }
26604
26605
26606 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26607 PyObject *resultobj = 0;
26608 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26609 bool arg2 ;
26610 void *argp1 = 0 ;
26611 int res1 = 0 ;
26612 bool val2 ;
26613 int ecode2 = 0 ;
26614 PyObject * obj0 = 0 ;
26615 PyObject * obj1 = 0 ;
26616 char * kwnames[] = {
26617 (char *) "self",(char *) "forward", NULL
26618 };
26619
26620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26622 if (!SWIG_IsOK(res1)) {
26623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26624 }
26625 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26626 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26627 if (!SWIG_IsOK(ecode2)) {
26628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26629 }
26630 arg2 = static_cast< bool >(val2);
26631 {
26632 PyThreadState* __tstate = wxPyBeginAllowThreads();
26633 (arg1)->SetDirection(arg2);
26634 wxPyEndAllowThreads(__tstate);
26635 if (PyErr_Occurred()) SWIG_fail;
26636 }
26637 resultobj = SWIG_Py_Void();
26638 return resultobj;
26639 fail:
26640 return NULL;
26641 }
26642
26643
26644 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26645 PyObject *resultobj = 0;
26646 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26647 bool result;
26648 void *argp1 = 0 ;
26649 int res1 = 0 ;
26650 PyObject *swig_obj[1] ;
26651
26652 if (!args) SWIG_fail;
26653 swig_obj[0] = args;
26654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26655 if (!SWIG_IsOK(res1)) {
26656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26657 }
26658 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26659 {
26660 PyThreadState* __tstate = wxPyBeginAllowThreads();
26661 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 {
26666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26667 }
26668 return resultobj;
26669 fail:
26670 return NULL;
26671 }
26672
26673
26674 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26675 PyObject *resultobj = 0;
26676 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26677 bool arg2 ;
26678 void *argp1 = 0 ;
26679 int res1 = 0 ;
26680 bool val2 ;
26681 int ecode2 = 0 ;
26682 PyObject * obj0 = 0 ;
26683 PyObject * obj1 = 0 ;
26684 char * kwnames[] = {
26685 (char *) "self",(char *) "ischange", NULL
26686 };
26687
26688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26690 if (!SWIG_IsOK(res1)) {
26691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26692 }
26693 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26694 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26695 if (!SWIG_IsOK(ecode2)) {
26696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26697 }
26698 arg2 = static_cast< bool >(val2);
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 (arg1)->SetWindowChange(arg2);
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_Py_Void();
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26713 PyObject *resultobj = 0;
26714 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26715 bool result;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 PyObject *swig_obj[1] ;
26719
26720 if (!args) SWIG_fail;
26721 swig_obj[0] = args;
26722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26723 if (!SWIG_IsOK(res1)) {
26724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26725 }
26726 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26730 wxPyEndAllowThreads(__tstate);
26731 if (PyErr_Occurred()) SWIG_fail;
26732 }
26733 {
26734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26735 }
26736 return resultobj;
26737 fail:
26738 return NULL;
26739 }
26740
26741
26742 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26743 PyObject *resultobj = 0;
26744 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26745 bool arg2 ;
26746 void *argp1 = 0 ;
26747 int res1 = 0 ;
26748 bool val2 ;
26749 int ecode2 = 0 ;
26750 PyObject * obj0 = 0 ;
26751 PyObject * obj1 = 0 ;
26752 char * kwnames[] = {
26753 (char *) "self",(char *) "bIs", NULL
26754 };
26755
26756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26758 if (!SWIG_IsOK(res1)) {
26759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26760 }
26761 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26763 if (!SWIG_IsOK(ecode2)) {
26764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26765 }
26766 arg2 = static_cast< bool >(val2);
26767 {
26768 PyThreadState* __tstate = wxPyBeginAllowThreads();
26769 (arg1)->SetFromTab(arg2);
26770 wxPyEndAllowThreads(__tstate);
26771 if (PyErr_Occurred()) SWIG_fail;
26772 }
26773 resultobj = SWIG_Py_Void();
26774 return resultobj;
26775 fail:
26776 return NULL;
26777 }
26778
26779
26780 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26781 PyObject *resultobj = 0;
26782 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26783 long arg2 ;
26784 void *argp1 = 0 ;
26785 int res1 = 0 ;
26786 long val2 ;
26787 int ecode2 = 0 ;
26788 PyObject * obj0 = 0 ;
26789 PyObject * obj1 = 0 ;
26790 char * kwnames[] = {
26791 (char *) "self",(char *) "flags", NULL
26792 };
26793
26794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26796 if (!SWIG_IsOK(res1)) {
26797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26798 }
26799 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26800 ecode2 = SWIG_AsVal_long(obj1, &val2);
26801 if (!SWIG_IsOK(ecode2)) {
26802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26803 }
26804 arg2 = static_cast< long >(val2);
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 (arg1)->SetFlags(arg2);
26808 wxPyEndAllowThreads(__tstate);
26809 if (PyErr_Occurred()) SWIG_fail;
26810 }
26811 resultobj = SWIG_Py_Void();
26812 return resultobj;
26813 fail:
26814 return NULL;
26815 }
26816
26817
26818 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26819 PyObject *resultobj = 0;
26820 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26821 wxWindow *result = 0 ;
26822 void *argp1 = 0 ;
26823 int res1 = 0 ;
26824 PyObject *swig_obj[1] ;
26825
26826 if (!args) SWIG_fail;
26827 swig_obj[0] = args;
26828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26829 if (!SWIG_IsOK(res1)) {
26830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26831 }
26832 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26836 wxPyEndAllowThreads(__tstate);
26837 if (PyErr_Occurred()) SWIG_fail;
26838 }
26839 {
26840 resultobj = wxPyMake_wxObject(result, (bool)0);
26841 }
26842 return resultobj;
26843 fail:
26844 return NULL;
26845 }
26846
26847
26848 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26849 PyObject *resultobj = 0;
26850 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26851 wxWindow *arg2 = (wxWindow *) 0 ;
26852 void *argp1 = 0 ;
26853 int res1 = 0 ;
26854 void *argp2 = 0 ;
26855 int res2 = 0 ;
26856 PyObject * obj0 = 0 ;
26857 PyObject * obj1 = 0 ;
26858 char * kwnames[] = {
26859 (char *) "self",(char *) "win", NULL
26860 };
26861
26862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26864 if (!SWIG_IsOK(res1)) {
26865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26866 }
26867 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26869 if (!SWIG_IsOK(res2)) {
26870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26871 }
26872 arg2 = reinterpret_cast< wxWindow * >(argp2);
26873 {
26874 PyThreadState* __tstate = wxPyBeginAllowThreads();
26875 (arg1)->SetCurrentFocus(arg2);
26876 wxPyEndAllowThreads(__tstate);
26877 if (PyErr_Occurred()) SWIG_fail;
26878 }
26879 resultobj = SWIG_Py_Void();
26880 return resultobj;
26881 fail:
26882 return NULL;
26883 }
26884
26885
26886 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26887 PyObject *obj;
26888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26889 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26890 return SWIG_Py_Void();
26891 }
26892
26893 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26894 return SWIG_Python_InitShadowInstance(args);
26895 }
26896
26897 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26898 PyObject *resultobj = 0;
26899 wxWindow *arg1 = (wxWindow *) NULL ;
26900 wxWindowCreateEvent *result = 0 ;
26901 void *argp1 = 0 ;
26902 int res1 = 0 ;
26903 PyObject * obj0 = 0 ;
26904 char * kwnames[] = {
26905 (char *) "win", NULL
26906 };
26907
26908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26909 if (obj0) {
26910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26911 if (!SWIG_IsOK(res1)) {
26912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26913 }
26914 arg1 = reinterpret_cast< wxWindow * >(argp1);
26915 }
26916 {
26917 PyThreadState* __tstate = wxPyBeginAllowThreads();
26918 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26919 wxPyEndAllowThreads(__tstate);
26920 if (PyErr_Occurred()) SWIG_fail;
26921 }
26922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26923 return resultobj;
26924 fail:
26925 return NULL;
26926 }
26927
26928
26929 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26930 PyObject *resultobj = 0;
26931 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26932 wxWindow *result = 0 ;
26933 void *argp1 = 0 ;
26934 int res1 = 0 ;
26935 PyObject *swig_obj[1] ;
26936
26937 if (!args) SWIG_fail;
26938 swig_obj[0] = args;
26939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26940 if (!SWIG_IsOK(res1)) {
26941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26942 }
26943 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 {
26951 resultobj = wxPyMake_wxObject(result, (bool)0);
26952 }
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26960 PyObject *obj;
26961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26962 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26963 return SWIG_Py_Void();
26964 }
26965
26966 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26967 return SWIG_Python_InitShadowInstance(args);
26968 }
26969
26970 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26971 PyObject *resultobj = 0;
26972 wxWindow *arg1 = (wxWindow *) NULL ;
26973 wxWindowDestroyEvent *result = 0 ;
26974 void *argp1 = 0 ;
26975 int res1 = 0 ;
26976 PyObject * obj0 = 0 ;
26977 char * kwnames[] = {
26978 (char *) "win", NULL
26979 };
26980
26981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26982 if (obj0) {
26983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26984 if (!SWIG_IsOK(res1)) {
26985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26986 }
26987 arg1 = reinterpret_cast< wxWindow * >(argp1);
26988 }
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26992 wxPyEndAllowThreads(__tstate);
26993 if (PyErr_Occurred()) SWIG_fail;
26994 }
26995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26996 return resultobj;
26997 fail:
26998 return NULL;
26999 }
27000
27001
27002 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27003 PyObject *resultobj = 0;
27004 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
27005 wxWindow *result = 0 ;
27006 void *argp1 = 0 ;
27007 int res1 = 0 ;
27008 PyObject *swig_obj[1] ;
27009
27010 if (!args) SWIG_fail;
27011 swig_obj[0] = args;
27012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
27013 if (!SWIG_IsOK(res1)) {
27014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27015 }
27016 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27017 {
27018 PyThreadState* __tstate = wxPyBeginAllowThreads();
27019 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 {
27024 resultobj = wxPyMake_wxObject(result, (bool)0);
27025 }
27026 return resultobj;
27027 fail:
27028 return NULL;
27029 }
27030
27031
27032 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27033 PyObject *obj;
27034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27035 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27036 return SWIG_Py_Void();
27037 }
27038
27039 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27040 return SWIG_Python_InitShadowInstance(args);
27041 }
27042
27043 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27044 PyObject *resultobj = 0;
27045 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27046 int arg2 = (int) 0 ;
27047 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27048 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27049 wxContextMenuEvent *result = 0 ;
27050 int val1 ;
27051 int ecode1 = 0 ;
27052 int val2 ;
27053 int ecode2 = 0 ;
27054 wxPoint temp3 ;
27055 PyObject * obj0 = 0 ;
27056 PyObject * obj1 = 0 ;
27057 PyObject * obj2 = 0 ;
27058 char * kwnames[] = {
27059 (char *) "type",(char *) "winid",(char *) "pt", NULL
27060 };
27061
27062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27063 if (obj0) {
27064 ecode1 = SWIG_AsVal_int(obj0, &val1);
27065 if (!SWIG_IsOK(ecode1)) {
27066 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27067 }
27068 arg1 = static_cast< wxEventType >(val1);
27069 }
27070 if (obj1) {
27071 ecode2 = SWIG_AsVal_int(obj1, &val2);
27072 if (!SWIG_IsOK(ecode2)) {
27073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27074 }
27075 arg2 = static_cast< int >(val2);
27076 }
27077 if (obj2) {
27078 {
27079 arg3 = &temp3;
27080 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27081 }
27082 }
27083 {
27084 PyThreadState* __tstate = wxPyBeginAllowThreads();
27085 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27086 wxPyEndAllowThreads(__tstate);
27087 if (PyErr_Occurred()) SWIG_fail;
27088 }
27089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27090 return resultobj;
27091 fail:
27092 return NULL;
27093 }
27094
27095
27096 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27097 PyObject *resultobj = 0;
27098 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27099 wxPoint *result = 0 ;
27100 void *argp1 = 0 ;
27101 int res1 = 0 ;
27102 PyObject *swig_obj[1] ;
27103
27104 if (!args) SWIG_fail;
27105 swig_obj[0] = args;
27106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27107 if (!SWIG_IsOK(res1)) {
27108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27109 }
27110 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27111 {
27112 PyThreadState* __tstate = wxPyBeginAllowThreads();
27113 {
27114 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27115 result = (wxPoint *) &_result_ref;
27116 }
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27121 return resultobj;
27122 fail:
27123 return NULL;
27124 }
27125
27126
27127 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27128 PyObject *resultobj = 0;
27129 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27130 wxPoint *arg2 = 0 ;
27131 void *argp1 = 0 ;
27132 int res1 = 0 ;
27133 wxPoint temp2 ;
27134 PyObject * obj0 = 0 ;
27135 PyObject * obj1 = 0 ;
27136 char * kwnames[] = {
27137 (char *) "self",(char *) "pos", NULL
27138 };
27139
27140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27142 if (!SWIG_IsOK(res1)) {
27143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27144 }
27145 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27146 {
27147 arg2 = &temp2;
27148 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27149 }
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 (arg1)->SetPosition((wxPoint const &)*arg2);
27153 wxPyEndAllowThreads(__tstate);
27154 if (PyErr_Occurred()) SWIG_fail;
27155 }
27156 resultobj = SWIG_Py_Void();
27157 return resultobj;
27158 fail:
27159 return NULL;
27160 }
27161
27162
27163 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27164 PyObject *obj;
27165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27166 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27167 return SWIG_Py_Void();
27168 }
27169
27170 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27171 return SWIG_Python_InitShadowInstance(args);
27172 }
27173
27174 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27175 PyObject *resultobj = 0;
27176 wxIdleEvent *result = 0 ;
27177
27178 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27179 {
27180 PyThreadState* __tstate = wxPyBeginAllowThreads();
27181 result = (wxIdleEvent *)new wxIdleEvent();
27182 wxPyEndAllowThreads(__tstate);
27183 if (PyErr_Occurred()) SWIG_fail;
27184 }
27185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27186 return resultobj;
27187 fail:
27188 return NULL;
27189 }
27190
27191
27192 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27193 PyObject *resultobj = 0;
27194 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27195 bool arg2 = (bool) true ;
27196 void *argp1 = 0 ;
27197 int res1 = 0 ;
27198 bool val2 ;
27199 int ecode2 = 0 ;
27200 PyObject * obj0 = 0 ;
27201 PyObject * obj1 = 0 ;
27202 char * kwnames[] = {
27203 (char *) "self",(char *) "needMore", NULL
27204 };
27205
27206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27208 if (!SWIG_IsOK(res1)) {
27209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27210 }
27211 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27212 if (obj1) {
27213 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27214 if (!SWIG_IsOK(ecode2)) {
27215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27216 }
27217 arg2 = static_cast< bool >(val2);
27218 }
27219 {
27220 PyThreadState* __tstate = wxPyBeginAllowThreads();
27221 (arg1)->RequestMore(arg2);
27222 wxPyEndAllowThreads(__tstate);
27223 if (PyErr_Occurred()) SWIG_fail;
27224 }
27225 resultobj = SWIG_Py_Void();
27226 return resultobj;
27227 fail:
27228 return NULL;
27229 }
27230
27231
27232 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27233 PyObject *resultobj = 0;
27234 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27235 bool result;
27236 void *argp1 = 0 ;
27237 int res1 = 0 ;
27238 PyObject *swig_obj[1] ;
27239
27240 if (!args) SWIG_fail;
27241 swig_obj[0] = args;
27242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27243 if (!SWIG_IsOK(res1)) {
27244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27245 }
27246 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27247 {
27248 PyThreadState* __tstate = wxPyBeginAllowThreads();
27249 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27250 wxPyEndAllowThreads(__tstate);
27251 if (PyErr_Occurred()) SWIG_fail;
27252 }
27253 {
27254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27255 }
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27263 PyObject *resultobj = 0;
27264 wxIdleMode arg1 ;
27265 int val1 ;
27266 int ecode1 = 0 ;
27267 PyObject * obj0 = 0 ;
27268 char * kwnames[] = {
27269 (char *) "mode", NULL
27270 };
27271
27272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27273 ecode1 = SWIG_AsVal_int(obj0, &val1);
27274 if (!SWIG_IsOK(ecode1)) {
27275 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27276 }
27277 arg1 = static_cast< wxIdleMode >(val1);
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 wxIdleEvent::SetMode(arg1);
27281 wxPyEndAllowThreads(__tstate);
27282 if (PyErr_Occurred()) SWIG_fail;
27283 }
27284 resultobj = SWIG_Py_Void();
27285 return resultobj;
27286 fail:
27287 return NULL;
27288 }
27289
27290
27291 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27292 PyObject *resultobj = 0;
27293 wxIdleMode result;
27294
27295 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27296 {
27297 PyThreadState* __tstate = wxPyBeginAllowThreads();
27298 result = (wxIdleMode)wxIdleEvent::GetMode();
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 resultobj = SWIG_From_int(static_cast< int >(result));
27303 return resultobj;
27304 fail:
27305 return NULL;
27306 }
27307
27308
27309 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27310 PyObject *resultobj = 0;
27311 wxWindow *arg1 = (wxWindow *) 0 ;
27312 bool result;
27313 void *argp1 = 0 ;
27314 int res1 = 0 ;
27315 PyObject * obj0 = 0 ;
27316 char * kwnames[] = {
27317 (char *) "win", NULL
27318 };
27319
27320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27322 if (!SWIG_IsOK(res1)) {
27323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27324 }
27325 arg1 = reinterpret_cast< wxWindow * >(argp1);
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 result = (bool)wxIdleEvent::CanSend(arg1);
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 {
27333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27334 }
27335 return resultobj;
27336 fail:
27337 return NULL;
27338 }
27339
27340
27341 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27342 PyObject *obj;
27343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27344 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27345 return SWIG_Py_Void();
27346 }
27347
27348 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27349 return SWIG_Python_InitShadowInstance(args);
27350 }
27351
27352 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27353 PyObject *resultobj = 0;
27354 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27355 int arg2 = (int) 0 ;
27356 wxClipboardTextEvent *result = 0 ;
27357 int val1 ;
27358 int ecode1 = 0 ;
27359 int val2 ;
27360 int ecode2 = 0 ;
27361 PyObject * obj0 = 0 ;
27362 PyObject * obj1 = 0 ;
27363 char * kwnames[] = {
27364 (char *) "type",(char *) "winid", NULL
27365 };
27366
27367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27368 if (obj0) {
27369 ecode1 = SWIG_AsVal_int(obj0, &val1);
27370 if (!SWIG_IsOK(ecode1)) {
27371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27372 }
27373 arg1 = static_cast< wxEventType >(val1);
27374 }
27375 if (obj1) {
27376 ecode2 = SWIG_AsVal_int(obj1, &val2);
27377 if (!SWIG_IsOK(ecode2)) {
27378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27379 }
27380 arg2 = static_cast< int >(val2);
27381 }
27382 {
27383 PyThreadState* __tstate = wxPyBeginAllowThreads();
27384 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27385 wxPyEndAllowThreads(__tstate);
27386 if (PyErr_Occurred()) SWIG_fail;
27387 }
27388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27389 return resultobj;
27390 fail:
27391 return NULL;
27392 }
27393
27394
27395 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27396 PyObject *obj;
27397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27398 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27399 return SWIG_Py_Void();
27400 }
27401
27402 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27403 return SWIG_Python_InitShadowInstance(args);
27404 }
27405
27406 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27407 PyObject *resultobj = 0;
27408 int arg1 = (int) 0 ;
27409 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27410 wxPyEvent *result = 0 ;
27411 int val1 ;
27412 int ecode1 = 0 ;
27413 int val2 ;
27414 int ecode2 = 0 ;
27415 PyObject * obj0 = 0 ;
27416 PyObject * obj1 = 0 ;
27417 char * kwnames[] = {
27418 (char *) "winid",(char *) "eventType", NULL
27419 };
27420
27421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27422 if (obj0) {
27423 ecode1 = SWIG_AsVal_int(obj0, &val1);
27424 if (!SWIG_IsOK(ecode1)) {
27425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27426 }
27427 arg1 = static_cast< int >(val1);
27428 }
27429 if (obj1) {
27430 ecode2 = SWIG_AsVal_int(obj1, &val2);
27431 if (!SWIG_IsOK(ecode2)) {
27432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27433 }
27434 arg2 = static_cast< wxEventType >(val2);
27435 }
27436 {
27437 PyThreadState* __tstate = wxPyBeginAllowThreads();
27438 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27439 wxPyEndAllowThreads(__tstate);
27440 if (PyErr_Occurred()) SWIG_fail;
27441 }
27442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27443 return resultobj;
27444 fail:
27445 return NULL;
27446 }
27447
27448
27449 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27450 PyObject *resultobj = 0;
27451 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27452 void *argp1 = 0 ;
27453 int res1 = 0 ;
27454 PyObject *swig_obj[1] ;
27455
27456 if (!args) SWIG_fail;
27457 swig_obj[0] = args;
27458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27459 if (!SWIG_IsOK(res1)) {
27460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27461 }
27462 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27463 {
27464 PyThreadState* __tstate = wxPyBeginAllowThreads();
27465 delete arg1;
27466
27467 wxPyEndAllowThreads(__tstate);
27468 if (PyErr_Occurred()) SWIG_fail;
27469 }
27470 resultobj = SWIG_Py_Void();
27471 return resultobj;
27472 fail:
27473 return NULL;
27474 }
27475
27476
27477 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27478 PyObject *resultobj = 0;
27479 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27480 PyObject *arg2 = (PyObject *) 0 ;
27481 void *argp1 = 0 ;
27482 int res1 = 0 ;
27483 PyObject * obj0 = 0 ;
27484 PyObject * obj1 = 0 ;
27485 char * kwnames[] = {
27486 (char *) "self",(char *) "self", NULL
27487 };
27488
27489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27491 if (!SWIG_IsOK(res1)) {
27492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27493 }
27494 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27495 arg2 = obj1;
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 (arg1)->SetSelf(arg2);
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 resultobj = SWIG_Py_Void();
27503 return resultobj;
27504 fail:
27505 return NULL;
27506 }
27507
27508
27509 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27510 PyObject *resultobj = 0;
27511 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27512 PyObject *result = 0 ;
27513 void *argp1 = 0 ;
27514 int res1 = 0 ;
27515 PyObject *swig_obj[1] ;
27516
27517 if (!args) SWIG_fail;
27518 swig_obj[0] = args;
27519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27520 if (!SWIG_IsOK(res1)) {
27521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27522 }
27523 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27524 {
27525 PyThreadState* __tstate = wxPyBeginAllowThreads();
27526 result = (PyObject *)(arg1)->GetSelf();
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 resultobj = result;
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27538 PyObject *obj;
27539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27540 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27541 return SWIG_Py_Void();
27542 }
27543
27544 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27545 return SWIG_Python_InitShadowInstance(args);
27546 }
27547
27548 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27549 PyObject *resultobj = 0;
27550 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27551 int arg2 = (int) 0 ;
27552 wxPyCommandEvent *result = 0 ;
27553 int val1 ;
27554 int ecode1 = 0 ;
27555 int val2 ;
27556 int ecode2 = 0 ;
27557 PyObject * obj0 = 0 ;
27558 PyObject * obj1 = 0 ;
27559 char * kwnames[] = {
27560 (char *) "eventType",(char *) "id", NULL
27561 };
27562
27563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27564 if (obj0) {
27565 ecode1 = SWIG_AsVal_int(obj0, &val1);
27566 if (!SWIG_IsOK(ecode1)) {
27567 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27568 }
27569 arg1 = static_cast< wxEventType >(val1);
27570 }
27571 if (obj1) {
27572 ecode2 = SWIG_AsVal_int(obj1, &val2);
27573 if (!SWIG_IsOK(ecode2)) {
27574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27575 }
27576 arg2 = static_cast< int >(val2);
27577 }
27578 {
27579 PyThreadState* __tstate = wxPyBeginAllowThreads();
27580 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27585 return resultobj;
27586 fail:
27587 return NULL;
27588 }
27589
27590
27591 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27592 PyObject *resultobj = 0;
27593 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27594 void *argp1 = 0 ;
27595 int res1 = 0 ;
27596 PyObject *swig_obj[1] ;
27597
27598 if (!args) SWIG_fail;
27599 swig_obj[0] = args;
27600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27601 if (!SWIG_IsOK(res1)) {
27602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27603 }
27604 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27605 {
27606 PyThreadState* __tstate = wxPyBeginAllowThreads();
27607 delete arg1;
27608
27609 wxPyEndAllowThreads(__tstate);
27610 if (PyErr_Occurred()) SWIG_fail;
27611 }
27612 resultobj = SWIG_Py_Void();
27613 return resultobj;
27614 fail:
27615 return NULL;
27616 }
27617
27618
27619 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27620 PyObject *resultobj = 0;
27621 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27622 PyObject *arg2 = (PyObject *) 0 ;
27623 void *argp1 = 0 ;
27624 int res1 = 0 ;
27625 PyObject * obj0 = 0 ;
27626 PyObject * obj1 = 0 ;
27627 char * kwnames[] = {
27628 (char *) "self",(char *) "self", NULL
27629 };
27630
27631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27633 if (!SWIG_IsOK(res1)) {
27634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27635 }
27636 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27637 arg2 = obj1;
27638 {
27639 PyThreadState* __tstate = wxPyBeginAllowThreads();
27640 (arg1)->SetSelf(arg2);
27641 wxPyEndAllowThreads(__tstate);
27642 if (PyErr_Occurred()) SWIG_fail;
27643 }
27644 resultobj = SWIG_Py_Void();
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27652 PyObject *resultobj = 0;
27653 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27654 PyObject *result = 0 ;
27655 void *argp1 = 0 ;
27656 int res1 = 0 ;
27657 PyObject *swig_obj[1] ;
27658
27659 if (!args) SWIG_fail;
27660 swig_obj[0] = args;
27661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27662 if (!SWIG_IsOK(res1)) {
27663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27664 }
27665 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 result = (PyObject *)(arg1)->GetSelf();
27669 wxPyEndAllowThreads(__tstate);
27670 if (PyErr_Occurred()) SWIG_fail;
27671 }
27672 resultobj = result;
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27680 PyObject *obj;
27681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27682 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27683 return SWIG_Py_Void();
27684 }
27685
27686 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27687 return SWIG_Python_InitShadowInstance(args);
27688 }
27689
27690 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27691 PyObject *resultobj = 0;
27692 wxWindow *arg1 = (wxWindow *) 0 ;
27693 wxDateTime *arg2 = 0 ;
27694 wxEventType arg3 ;
27695 wxDateEvent *result = 0 ;
27696 void *argp1 = 0 ;
27697 int res1 = 0 ;
27698 void *argp2 = 0 ;
27699 int res2 = 0 ;
27700 int val3 ;
27701 int ecode3 = 0 ;
27702 PyObject * obj0 = 0 ;
27703 PyObject * obj1 = 0 ;
27704 PyObject * obj2 = 0 ;
27705 char * kwnames[] = {
27706 (char *) "win",(char *) "dt",(char *) "type", NULL
27707 };
27708
27709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27711 if (!SWIG_IsOK(res1)) {
27712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27713 }
27714 arg1 = reinterpret_cast< wxWindow * >(argp1);
27715 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27716 if (!SWIG_IsOK(res2)) {
27717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27718 }
27719 if (!argp2) {
27720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27721 }
27722 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27723 ecode3 = SWIG_AsVal_int(obj2, &val3);
27724 if (!SWIG_IsOK(ecode3)) {
27725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27726 }
27727 arg3 = static_cast< wxEventType >(val3);
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27731 wxPyEndAllowThreads(__tstate);
27732 if (PyErr_Occurred()) SWIG_fail;
27733 }
27734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27742 PyObject *resultobj = 0;
27743 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27744 wxDateTime *result = 0 ;
27745 void *argp1 = 0 ;
27746 int res1 = 0 ;
27747 PyObject *swig_obj[1] ;
27748
27749 if (!args) SWIG_fail;
27750 swig_obj[0] = args;
27751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27752 if (!SWIG_IsOK(res1)) {
27753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27754 }
27755 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 {
27759 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27760 result = (wxDateTime *) &_result_ref;
27761 }
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27766 return resultobj;
27767 fail:
27768 return NULL;
27769 }
27770
27771
27772 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27773 PyObject *resultobj = 0;
27774 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27775 wxDateTime *arg2 = 0 ;
27776 void *argp1 = 0 ;
27777 int res1 = 0 ;
27778 void *argp2 = 0 ;
27779 int res2 = 0 ;
27780 PyObject * obj0 = 0 ;
27781 PyObject * obj1 = 0 ;
27782 char * kwnames[] = {
27783 (char *) "self",(char *) "date", NULL
27784 };
27785
27786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27788 if (!SWIG_IsOK(res1)) {
27789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27790 }
27791 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27792 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27793 if (!SWIG_IsOK(res2)) {
27794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27795 }
27796 if (!argp2) {
27797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27798 }
27799 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 (arg1)->SetDate((wxDateTime const &)*arg2);
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 resultobj = SWIG_Py_Void();
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27814 PyObject *obj;
27815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27816 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27817 return SWIG_Py_Void();
27818 }
27819
27820 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27821 return SWIG_Python_InitShadowInstance(args);
27822 }
27823
27824 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27825 PyObject *resultobj = 0;
27826 wxPyApp *result = 0 ;
27827
27828 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 result = (wxPyApp *)new_wxPyApp();
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27843 PyObject *resultobj = 0;
27844 wxPyApp *arg1 = (wxPyApp *) 0 ;
27845 void *argp1 = 0 ;
27846 int res1 = 0 ;
27847 PyObject *swig_obj[1] ;
27848
27849 if (!args) SWIG_fail;
27850 swig_obj[0] = args;
27851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27852 if (!SWIG_IsOK(res1)) {
27853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27854 }
27855 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27856 {
27857 PyThreadState* __tstate = wxPyBeginAllowThreads();
27858 delete arg1;
27859
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 resultobj = SWIG_Py_Void();
27864 return resultobj;
27865 fail:
27866 return NULL;
27867 }
27868
27869
27870 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27871 PyObject *resultobj = 0;
27872 wxPyApp *arg1 = (wxPyApp *) 0 ;
27873 PyObject *arg2 = (PyObject *) 0 ;
27874 PyObject *arg3 = (PyObject *) 0 ;
27875 bool arg4 ;
27876 void *argp1 = 0 ;
27877 int res1 = 0 ;
27878 bool val4 ;
27879 int ecode4 = 0 ;
27880 PyObject * obj0 = 0 ;
27881 PyObject * obj1 = 0 ;
27882 PyObject * obj2 = 0 ;
27883 PyObject * obj3 = 0 ;
27884 char * kwnames[] = {
27885 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27886 };
27887
27888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27890 if (!SWIG_IsOK(res1)) {
27891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27892 }
27893 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27894 arg2 = obj1;
27895 arg3 = obj2;
27896 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27897 if (!SWIG_IsOK(ecode4)) {
27898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27899 }
27900 arg4 = static_cast< bool >(val4);
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 resultobj = SWIG_Py_Void();
27908 return resultobj;
27909 fail:
27910 return NULL;
27911 }
27912
27913
27914 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27915 PyObject *resultobj = 0;
27916 wxPyApp *arg1 = (wxPyApp *) 0 ;
27917 wxString result;
27918 void *argp1 = 0 ;
27919 int res1 = 0 ;
27920 PyObject *swig_obj[1] ;
27921
27922 if (!args) SWIG_fail;
27923 swig_obj[0] = args;
27924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27925 if (!SWIG_IsOK(res1)) {
27926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27927 }
27928 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27929 {
27930 PyThreadState* __tstate = wxPyBeginAllowThreads();
27931 result = ((wxPyApp const *)arg1)->GetAppName();
27932 wxPyEndAllowThreads(__tstate);
27933 if (PyErr_Occurred()) SWIG_fail;
27934 }
27935 {
27936 #if wxUSE_UNICODE
27937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27938 #else
27939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27940 #endif
27941 }
27942 return resultobj;
27943 fail:
27944 return NULL;
27945 }
27946
27947
27948 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27949 PyObject *resultobj = 0;
27950 wxPyApp *arg1 = (wxPyApp *) 0 ;
27951 wxString *arg2 = 0 ;
27952 void *argp1 = 0 ;
27953 int res1 = 0 ;
27954 bool temp2 = false ;
27955 PyObject * obj0 = 0 ;
27956 PyObject * obj1 = 0 ;
27957 char * kwnames[] = {
27958 (char *) "self",(char *) "name", NULL
27959 };
27960
27961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27963 if (!SWIG_IsOK(res1)) {
27964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27965 }
27966 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27967 {
27968 arg2 = wxString_in_helper(obj1);
27969 if (arg2 == NULL) SWIG_fail;
27970 temp2 = true;
27971 }
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 (arg1)->SetAppName((wxString const &)*arg2);
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_Py_Void();
27979 {
27980 if (temp2)
27981 delete arg2;
27982 }
27983 return resultobj;
27984 fail:
27985 {
27986 if (temp2)
27987 delete arg2;
27988 }
27989 return NULL;
27990 }
27991
27992
27993 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27994 PyObject *resultobj = 0;
27995 wxPyApp *arg1 = (wxPyApp *) 0 ;
27996 wxString result;
27997 void *argp1 = 0 ;
27998 int res1 = 0 ;
27999 PyObject *swig_obj[1] ;
28000
28001 if (!args) SWIG_fail;
28002 swig_obj[0] = args;
28003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28004 if (!SWIG_IsOK(res1)) {
28005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28006 }
28007 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28008 {
28009 PyThreadState* __tstate = wxPyBeginAllowThreads();
28010 result = ((wxPyApp const *)arg1)->GetClassName();
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 {
28015 #if wxUSE_UNICODE
28016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28017 #else
28018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28019 #endif
28020 }
28021 return resultobj;
28022 fail:
28023 return NULL;
28024 }
28025
28026
28027 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28028 PyObject *resultobj = 0;
28029 wxPyApp *arg1 = (wxPyApp *) 0 ;
28030 wxString *arg2 = 0 ;
28031 void *argp1 = 0 ;
28032 int res1 = 0 ;
28033 bool temp2 = false ;
28034 PyObject * obj0 = 0 ;
28035 PyObject * obj1 = 0 ;
28036 char * kwnames[] = {
28037 (char *) "self",(char *) "name", NULL
28038 };
28039
28040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28042 if (!SWIG_IsOK(res1)) {
28043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28044 }
28045 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28046 {
28047 arg2 = wxString_in_helper(obj1);
28048 if (arg2 == NULL) SWIG_fail;
28049 temp2 = true;
28050 }
28051 {
28052 PyThreadState* __tstate = wxPyBeginAllowThreads();
28053 (arg1)->SetClassName((wxString const &)*arg2);
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 resultobj = SWIG_Py_Void();
28058 {
28059 if (temp2)
28060 delete arg2;
28061 }
28062 return resultobj;
28063 fail:
28064 {
28065 if (temp2)
28066 delete arg2;
28067 }
28068 return NULL;
28069 }
28070
28071
28072 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28073 PyObject *resultobj = 0;
28074 wxPyApp *arg1 = (wxPyApp *) 0 ;
28075 wxString *result = 0 ;
28076 void *argp1 = 0 ;
28077 int res1 = 0 ;
28078 PyObject *swig_obj[1] ;
28079
28080 if (!args) SWIG_fail;
28081 swig_obj[0] = args;
28082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28083 if (!SWIG_IsOK(res1)) {
28084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28085 }
28086 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28087 {
28088 PyThreadState* __tstate = wxPyBeginAllowThreads();
28089 {
28090 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28091 result = (wxString *) &_result_ref;
28092 }
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 {
28097 #if wxUSE_UNICODE
28098 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28099 #else
28100 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28101 #endif
28102 }
28103 return resultobj;
28104 fail:
28105 return NULL;
28106 }
28107
28108
28109 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28110 PyObject *resultobj = 0;
28111 wxPyApp *arg1 = (wxPyApp *) 0 ;
28112 wxString *arg2 = 0 ;
28113 void *argp1 = 0 ;
28114 int res1 = 0 ;
28115 bool temp2 = false ;
28116 PyObject * obj0 = 0 ;
28117 PyObject * obj1 = 0 ;
28118 char * kwnames[] = {
28119 (char *) "self",(char *) "name", NULL
28120 };
28121
28122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28124 if (!SWIG_IsOK(res1)) {
28125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28126 }
28127 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28128 {
28129 arg2 = wxString_in_helper(obj1);
28130 if (arg2 == NULL) SWIG_fail;
28131 temp2 = true;
28132 }
28133 {
28134 PyThreadState* __tstate = wxPyBeginAllowThreads();
28135 (arg1)->SetVendorName((wxString const &)*arg2);
28136 wxPyEndAllowThreads(__tstate);
28137 if (PyErr_Occurred()) SWIG_fail;
28138 }
28139 resultobj = SWIG_Py_Void();
28140 {
28141 if (temp2)
28142 delete arg2;
28143 }
28144 return resultobj;
28145 fail:
28146 {
28147 if (temp2)
28148 delete arg2;
28149 }
28150 return NULL;
28151 }
28152
28153
28154 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28155 PyObject *resultobj = 0;
28156 wxPyApp *arg1 = (wxPyApp *) 0 ;
28157 wxAppTraits *result = 0 ;
28158 void *argp1 = 0 ;
28159 int res1 = 0 ;
28160 PyObject *swig_obj[1] ;
28161
28162 if (!args) SWIG_fail;
28163 swig_obj[0] = args;
28164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28165 if (!SWIG_IsOK(res1)) {
28166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28167 }
28168 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28169 {
28170 PyThreadState* __tstate = wxPyBeginAllowThreads();
28171 result = (wxAppTraits *)(arg1)->GetTraits();
28172 wxPyEndAllowThreads(__tstate);
28173 if (PyErr_Occurred()) SWIG_fail;
28174 }
28175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28176 return resultobj;
28177 fail:
28178 return NULL;
28179 }
28180
28181
28182 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28183 PyObject *resultobj = 0;
28184 wxPyApp *arg1 = (wxPyApp *) 0 ;
28185 void *argp1 = 0 ;
28186 int res1 = 0 ;
28187 PyObject *swig_obj[1] ;
28188
28189 if (!args) SWIG_fail;
28190 swig_obj[0] = args;
28191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28192 if (!SWIG_IsOK(res1)) {
28193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28194 }
28195 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28196 {
28197 PyThreadState* __tstate = wxPyBeginAllowThreads();
28198 (arg1)->ProcessPendingEvents();
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 resultobj = SWIG_Py_Void();
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj = 0;
28211 wxPyApp *arg1 = (wxPyApp *) 0 ;
28212 bool arg2 = (bool) false ;
28213 bool result;
28214 void *argp1 = 0 ;
28215 int res1 = 0 ;
28216 bool val2 ;
28217 int ecode2 = 0 ;
28218 PyObject * obj0 = 0 ;
28219 PyObject * obj1 = 0 ;
28220 char * kwnames[] = {
28221 (char *) "self",(char *) "onlyIfNeeded", NULL
28222 };
28223
28224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28226 if (!SWIG_IsOK(res1)) {
28227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28228 }
28229 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28230 if (obj1) {
28231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28232 if (!SWIG_IsOK(ecode2)) {
28233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28234 }
28235 arg2 = static_cast< bool >(val2);
28236 }
28237 {
28238 PyThreadState* __tstate = wxPyBeginAllowThreads();
28239 result = (bool)(arg1)->Yield(arg2);
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_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28253 PyObject *resultobj = 0;
28254 wxPyApp *arg1 = (wxPyApp *) 0 ;
28255 void *argp1 = 0 ;
28256 int res1 = 0 ;
28257 PyObject *swig_obj[1] ;
28258
28259 if (!args) SWIG_fail;
28260 swig_obj[0] = args;
28261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28262 if (!SWIG_IsOK(res1)) {
28263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28264 }
28265 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28266 {
28267 PyThreadState* __tstate = wxPyBeginAllowThreads();
28268 (arg1)->WakeUpIdle();
28269 wxPyEndAllowThreads(__tstate);
28270 if (PyErr_Occurred()) SWIG_fail;
28271 }
28272 resultobj = SWIG_Py_Void();
28273 return resultobj;
28274 fail:
28275 return NULL;
28276 }
28277
28278
28279 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28280 PyObject *resultobj = 0;
28281 bool result;
28282
28283 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 result = (bool)wxPyApp::IsMainLoopRunning();
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 {
28291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28292 }
28293 return resultobj;
28294 fail:
28295 return NULL;
28296 }
28297
28298
28299 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28300 PyObject *resultobj = 0;
28301 wxPyApp *arg1 = (wxPyApp *) 0 ;
28302 int result;
28303 void *argp1 = 0 ;
28304 int res1 = 0 ;
28305 PyObject *swig_obj[1] ;
28306
28307 if (!args) SWIG_fail;
28308 swig_obj[0] = args;
28309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28310 if (!SWIG_IsOK(res1)) {
28311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28312 }
28313 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28314 {
28315 PyThreadState* __tstate = wxPyBeginAllowThreads();
28316 result = (int)(arg1)->MainLoop();
28317 wxPyEndAllowThreads(__tstate);
28318 if (PyErr_Occurred()) SWIG_fail;
28319 }
28320 resultobj = SWIG_From_int(static_cast< int >(result));
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28328 PyObject *resultobj = 0;
28329 wxPyApp *arg1 = (wxPyApp *) 0 ;
28330 void *argp1 = 0 ;
28331 int res1 = 0 ;
28332 PyObject *swig_obj[1] ;
28333
28334 if (!args) SWIG_fail;
28335 swig_obj[0] = args;
28336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28337 if (!SWIG_IsOK(res1)) {
28338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28339 }
28340 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28341 {
28342 PyThreadState* __tstate = wxPyBeginAllowThreads();
28343 (arg1)->Exit();
28344 wxPyEndAllowThreads(__tstate);
28345 if (PyErr_Occurred()) SWIG_fail;
28346 }
28347 resultobj = SWIG_Py_Void();
28348 return resultobj;
28349 fail:
28350 return NULL;
28351 }
28352
28353
28354 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28355 PyObject *resultobj = 0;
28356 wxPyApp *arg1 = (wxPyApp *) 0 ;
28357 wxLayoutDirection result;
28358 void *argp1 = 0 ;
28359 int res1 = 0 ;
28360 PyObject *swig_obj[1] ;
28361
28362 if (!args) SWIG_fail;
28363 swig_obj[0] = args;
28364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28365 if (!SWIG_IsOK(res1)) {
28366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28367 }
28368 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28372 wxPyEndAllowThreads(__tstate);
28373 if (PyErr_Occurred()) SWIG_fail;
28374 }
28375 resultobj = SWIG_From_int(static_cast< int >(result));
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28383 PyObject *resultobj = 0;
28384 wxPyApp *arg1 = (wxPyApp *) 0 ;
28385 void *argp1 = 0 ;
28386 int res1 = 0 ;
28387 PyObject *swig_obj[1] ;
28388
28389 if (!args) SWIG_fail;
28390 swig_obj[0] = args;
28391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28392 if (!SWIG_IsOK(res1)) {
28393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28394 }
28395 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28396 {
28397 PyThreadState* __tstate = wxPyBeginAllowThreads();
28398 (arg1)->ExitMainLoop();
28399 wxPyEndAllowThreads(__tstate);
28400 if (PyErr_Occurred()) SWIG_fail;
28401 }
28402 resultobj = SWIG_Py_Void();
28403 return resultobj;
28404 fail:
28405 return NULL;
28406 }
28407
28408
28409 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28410 PyObject *resultobj = 0;
28411 wxPyApp *arg1 = (wxPyApp *) 0 ;
28412 bool result;
28413 void *argp1 = 0 ;
28414 int res1 = 0 ;
28415 PyObject *swig_obj[1] ;
28416
28417 if (!args) SWIG_fail;
28418 swig_obj[0] = args;
28419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28420 if (!SWIG_IsOK(res1)) {
28421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28422 }
28423 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28424 {
28425 PyThreadState* __tstate = wxPyBeginAllowThreads();
28426 result = (bool)(arg1)->Pending();
28427 wxPyEndAllowThreads(__tstate);
28428 if (PyErr_Occurred()) SWIG_fail;
28429 }
28430 {
28431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28432 }
28433 return resultobj;
28434 fail:
28435 return NULL;
28436 }
28437
28438
28439 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28440 PyObject *resultobj = 0;
28441 wxPyApp *arg1 = (wxPyApp *) 0 ;
28442 bool result;
28443 void *argp1 = 0 ;
28444 int res1 = 0 ;
28445 PyObject *swig_obj[1] ;
28446
28447 if (!args) SWIG_fail;
28448 swig_obj[0] = args;
28449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28450 if (!SWIG_IsOK(res1)) {
28451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28452 }
28453 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 result = (bool)(arg1)->Dispatch();
28457 wxPyEndAllowThreads(__tstate);
28458 if (PyErr_Occurred()) SWIG_fail;
28459 }
28460 {
28461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28462 }
28463 return resultobj;
28464 fail:
28465 return NULL;
28466 }
28467
28468
28469 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28470 PyObject *resultobj = 0;
28471 wxPyApp *arg1 = (wxPyApp *) 0 ;
28472 bool result;
28473 void *argp1 = 0 ;
28474 int res1 = 0 ;
28475 PyObject *swig_obj[1] ;
28476
28477 if (!args) SWIG_fail;
28478 swig_obj[0] = args;
28479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28480 if (!SWIG_IsOK(res1)) {
28481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28482 }
28483 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 result = (bool)(arg1)->ProcessIdle();
28487 wxPyEndAllowThreads(__tstate);
28488 if (PyErr_Occurred()) SWIG_fail;
28489 }
28490 {
28491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28492 }
28493 return resultobj;
28494 fail:
28495 return NULL;
28496 }
28497
28498
28499 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28500 PyObject *resultobj = 0;
28501 wxPyApp *arg1 = (wxPyApp *) 0 ;
28502 wxWindow *arg2 = (wxWindow *) 0 ;
28503 wxIdleEvent *arg3 = 0 ;
28504 bool result;
28505 void *argp1 = 0 ;
28506 int res1 = 0 ;
28507 void *argp2 = 0 ;
28508 int res2 = 0 ;
28509 void *argp3 = 0 ;
28510 int res3 = 0 ;
28511 PyObject * obj0 = 0 ;
28512 PyObject * obj1 = 0 ;
28513 PyObject * obj2 = 0 ;
28514 char * kwnames[] = {
28515 (char *) "self",(char *) "win",(char *) "event", NULL
28516 };
28517
28518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28520 if (!SWIG_IsOK(res1)) {
28521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28522 }
28523 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28525 if (!SWIG_IsOK(res2)) {
28526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28527 }
28528 arg2 = reinterpret_cast< wxWindow * >(argp2);
28529 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28530 if (!SWIG_IsOK(res3)) {
28531 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28532 }
28533 if (!argp3) {
28534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28535 }
28536 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 {
28544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28545 }
28546 return resultobj;
28547 fail:
28548 return NULL;
28549 }
28550
28551
28552 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28553 PyObject *resultobj = 0;
28554 wxPyApp *arg1 = (wxPyApp *) 0 ;
28555 bool result;
28556 void *argp1 = 0 ;
28557 int res1 = 0 ;
28558 PyObject *swig_obj[1] ;
28559
28560 if (!args) SWIG_fail;
28561 swig_obj[0] = args;
28562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28563 if (!SWIG_IsOK(res1)) {
28564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28565 }
28566 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 result = (bool)((wxPyApp const *)arg1)->IsActive();
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 {
28574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28575 }
28576 return resultobj;
28577 fail:
28578 return NULL;
28579 }
28580
28581
28582 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28583 PyObject *resultobj = 0;
28584 wxPyApp *arg1 = (wxPyApp *) 0 ;
28585 wxWindow *arg2 = (wxWindow *) 0 ;
28586 void *argp1 = 0 ;
28587 int res1 = 0 ;
28588 void *argp2 = 0 ;
28589 int res2 = 0 ;
28590 PyObject * obj0 = 0 ;
28591 PyObject * obj1 = 0 ;
28592 char * kwnames[] = {
28593 (char *) "self",(char *) "win", NULL
28594 };
28595
28596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28598 if (!SWIG_IsOK(res1)) {
28599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28600 }
28601 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28603 if (!SWIG_IsOK(res2)) {
28604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28605 }
28606 arg2 = reinterpret_cast< wxWindow * >(argp2);
28607 {
28608 PyThreadState* __tstate = wxPyBeginAllowThreads();
28609 (arg1)->SetTopWindow(arg2);
28610 wxPyEndAllowThreads(__tstate);
28611 if (PyErr_Occurred()) SWIG_fail;
28612 }
28613 resultobj = SWIG_Py_Void();
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28621 PyObject *resultobj = 0;
28622 wxPyApp *arg1 = (wxPyApp *) 0 ;
28623 wxWindow *result = 0 ;
28624 void *argp1 = 0 ;
28625 int res1 = 0 ;
28626 PyObject *swig_obj[1] ;
28627
28628 if (!args) SWIG_fail;
28629 swig_obj[0] = args;
28630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28631 if (!SWIG_IsOK(res1)) {
28632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28633 }
28634 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28635 {
28636 PyThreadState* __tstate = wxPyBeginAllowThreads();
28637 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 {
28642 resultobj = wxPyMake_wxObject(result, (bool)0);
28643 }
28644 return resultobj;
28645 fail:
28646 return NULL;
28647 }
28648
28649
28650 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28651 PyObject *resultobj = 0;
28652 wxPyApp *arg1 = (wxPyApp *) 0 ;
28653 bool arg2 ;
28654 void *argp1 = 0 ;
28655 int res1 = 0 ;
28656 bool val2 ;
28657 int ecode2 = 0 ;
28658 PyObject * obj0 = 0 ;
28659 PyObject * obj1 = 0 ;
28660 char * kwnames[] = {
28661 (char *) "self",(char *) "flag", NULL
28662 };
28663
28664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28666 if (!SWIG_IsOK(res1)) {
28667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28668 }
28669 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28671 if (!SWIG_IsOK(ecode2)) {
28672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28673 }
28674 arg2 = static_cast< bool >(val2);
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 (arg1)->SetExitOnFrameDelete(arg2);
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 resultobj = SWIG_Py_Void();
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28689 PyObject *resultobj = 0;
28690 wxPyApp *arg1 = (wxPyApp *) 0 ;
28691 bool result;
28692 void *argp1 = 0 ;
28693 int res1 = 0 ;
28694 PyObject *swig_obj[1] ;
28695
28696 if (!args) SWIG_fail;
28697 swig_obj[0] = args;
28698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28699 if (!SWIG_IsOK(res1)) {
28700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28701 }
28702 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28703 {
28704 PyThreadState* __tstate = wxPyBeginAllowThreads();
28705 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28706 wxPyEndAllowThreads(__tstate);
28707 if (PyErr_Occurred()) SWIG_fail;
28708 }
28709 {
28710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28711 }
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj = 0;
28720 wxPyApp *arg1 = (wxPyApp *) 0 ;
28721 bool arg2 ;
28722 void *argp1 = 0 ;
28723 int res1 = 0 ;
28724 bool val2 ;
28725 int ecode2 = 0 ;
28726 PyObject * obj0 = 0 ;
28727 PyObject * obj1 = 0 ;
28728 char * kwnames[] = {
28729 (char *) "self",(char *) "flag", NULL
28730 };
28731
28732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28734 if (!SWIG_IsOK(res1)) {
28735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28736 }
28737 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28738 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28739 if (!SWIG_IsOK(ecode2)) {
28740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28741 }
28742 arg2 = static_cast< bool >(val2);
28743 {
28744 PyThreadState* __tstate = wxPyBeginAllowThreads();
28745 (arg1)->SetUseBestVisual(arg2);
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 resultobj = SWIG_Py_Void();
28750 return resultobj;
28751 fail:
28752 return NULL;
28753 }
28754
28755
28756 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28757 PyObject *resultobj = 0;
28758 wxPyApp *arg1 = (wxPyApp *) 0 ;
28759 bool result;
28760 void *argp1 = 0 ;
28761 int res1 = 0 ;
28762 PyObject *swig_obj[1] ;
28763
28764 if (!args) SWIG_fail;
28765 swig_obj[0] = args;
28766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28767 if (!SWIG_IsOK(res1)) {
28768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28769 }
28770 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28774 wxPyEndAllowThreads(__tstate);
28775 if (PyErr_Occurred()) SWIG_fail;
28776 }
28777 {
28778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28779 }
28780 return resultobj;
28781 fail:
28782 return NULL;
28783 }
28784
28785
28786 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28787 PyObject *resultobj = 0;
28788 wxPyApp *arg1 = (wxPyApp *) 0 ;
28789 int arg2 ;
28790 void *argp1 = 0 ;
28791 int res1 = 0 ;
28792 int val2 ;
28793 int ecode2 = 0 ;
28794 PyObject * obj0 = 0 ;
28795 PyObject * obj1 = 0 ;
28796 char * kwnames[] = {
28797 (char *) "self",(char *) "mode", NULL
28798 };
28799
28800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28802 if (!SWIG_IsOK(res1)) {
28803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28804 }
28805 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28806 ecode2 = SWIG_AsVal_int(obj1, &val2);
28807 if (!SWIG_IsOK(ecode2)) {
28808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28809 }
28810 arg2 = static_cast< int >(val2);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 (arg1)->SetPrintMode(arg2);
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_Py_Void();
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *resultobj = 0;
28826 wxPyApp *arg1 = (wxPyApp *) 0 ;
28827 int result;
28828 void *argp1 = 0 ;
28829 int res1 = 0 ;
28830 PyObject *swig_obj[1] ;
28831
28832 if (!args) SWIG_fail;
28833 swig_obj[0] = args;
28834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28835 if (!SWIG_IsOK(res1)) {
28836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28837 }
28838 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28842 wxPyEndAllowThreads(__tstate);
28843 if (PyErr_Occurred()) SWIG_fail;
28844 }
28845 resultobj = SWIG_From_int(static_cast< int >(result));
28846 return resultobj;
28847 fail:
28848 return NULL;
28849 }
28850
28851
28852 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28853 PyObject *resultobj = 0;
28854 wxPyApp *arg1 = (wxPyApp *) 0 ;
28855 int arg2 ;
28856 void *argp1 = 0 ;
28857 int res1 = 0 ;
28858 int val2 ;
28859 int ecode2 = 0 ;
28860 PyObject * obj0 = 0 ;
28861 PyObject * obj1 = 0 ;
28862 char * kwnames[] = {
28863 (char *) "self",(char *) "mode", NULL
28864 };
28865
28866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28868 if (!SWIG_IsOK(res1)) {
28869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28870 }
28871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28872 ecode2 = SWIG_AsVal_int(obj1, &val2);
28873 if (!SWIG_IsOK(ecode2)) {
28874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28875 }
28876 arg2 = static_cast< int >(val2);
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 (arg1)->SetAssertMode(arg2);
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_Py_Void();
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28891 PyObject *resultobj = 0;
28892 wxPyApp *arg1 = (wxPyApp *) 0 ;
28893 int result;
28894 void *argp1 = 0 ;
28895 int res1 = 0 ;
28896 PyObject *swig_obj[1] ;
28897
28898 if (!args) SWIG_fail;
28899 swig_obj[0] = args;
28900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28901 if (!SWIG_IsOK(res1)) {
28902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28903 }
28904 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = (int)(arg1)->GetAssertMode();
28908 wxPyEndAllowThreads(__tstate);
28909 if (PyErr_Occurred()) SWIG_fail;
28910 }
28911 resultobj = SWIG_From_int(static_cast< int >(result));
28912 return resultobj;
28913 fail:
28914 return NULL;
28915 }
28916
28917
28918 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28919 PyObject *resultobj = 0;
28920 bool result;
28921
28922 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28923 {
28924 PyThreadState* __tstate = wxPyBeginAllowThreads();
28925 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28926 wxPyEndAllowThreads(__tstate);
28927 if (PyErr_Occurred()) SWIG_fail;
28928 }
28929 {
28930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28931 }
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28939 PyObject *resultobj = 0;
28940 long result;
28941
28942 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (long)wxPyApp::GetMacAboutMenuItemId();
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 resultobj = SWIG_From_long(static_cast< long >(result));
28950 return resultobj;
28951 fail:
28952 return NULL;
28953 }
28954
28955
28956 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28957 PyObject *resultobj = 0;
28958 long result;
28959
28960 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28961 {
28962 PyThreadState* __tstate = wxPyBeginAllowThreads();
28963 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28964 wxPyEndAllowThreads(__tstate);
28965 if (PyErr_Occurred()) SWIG_fail;
28966 }
28967 resultobj = SWIG_From_long(static_cast< long >(result));
28968 return resultobj;
28969 fail:
28970 return NULL;
28971 }
28972
28973
28974 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28975 PyObject *resultobj = 0;
28976 long result;
28977
28978 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 result = (long)wxPyApp::GetMacExitMenuItemId();
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 resultobj = SWIG_From_long(static_cast< long >(result));
28986 return resultobj;
28987 fail:
28988 return NULL;
28989 }
28990
28991
28992 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28993 PyObject *resultobj = 0;
28994 wxString result;
28995
28996 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28997 {
28998 PyThreadState* __tstate = wxPyBeginAllowThreads();
28999 result = wxPyApp::GetMacHelpMenuTitleName();
29000 wxPyEndAllowThreads(__tstate);
29001 if (PyErr_Occurred()) SWIG_fail;
29002 }
29003 {
29004 #if wxUSE_UNICODE
29005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29006 #else
29007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29008 #endif
29009 }
29010 return resultobj;
29011 fail:
29012 return NULL;
29013 }
29014
29015
29016 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29017 PyObject *resultobj = 0;
29018 bool arg1 ;
29019 bool val1 ;
29020 int ecode1 = 0 ;
29021 PyObject * obj0 = 0 ;
29022 char * kwnames[] = {
29023 (char *) "val", NULL
29024 };
29025
29026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29027 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29028 if (!SWIG_IsOK(ecode1)) {
29029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29030 }
29031 arg1 = static_cast< bool >(val1);
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29035 wxPyEndAllowThreads(__tstate);
29036 if (PyErr_Occurred()) SWIG_fail;
29037 }
29038 resultobj = SWIG_Py_Void();
29039 return resultobj;
29040 fail:
29041 return NULL;
29042 }
29043
29044
29045 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29046 PyObject *resultobj = 0;
29047 long arg1 ;
29048 long val1 ;
29049 int ecode1 = 0 ;
29050 PyObject * obj0 = 0 ;
29051 char * kwnames[] = {
29052 (char *) "val", NULL
29053 };
29054
29055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29056 ecode1 = SWIG_AsVal_long(obj0, &val1);
29057 if (!SWIG_IsOK(ecode1)) {
29058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29059 }
29060 arg1 = static_cast< long >(val1);
29061 {
29062 PyThreadState* __tstate = wxPyBeginAllowThreads();
29063 wxPyApp::SetMacAboutMenuItemId(arg1);
29064 wxPyEndAllowThreads(__tstate);
29065 if (PyErr_Occurred()) SWIG_fail;
29066 }
29067 resultobj = SWIG_Py_Void();
29068 return resultobj;
29069 fail:
29070 return NULL;
29071 }
29072
29073
29074 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29075 PyObject *resultobj = 0;
29076 long arg1 ;
29077 long val1 ;
29078 int ecode1 = 0 ;
29079 PyObject * obj0 = 0 ;
29080 char * kwnames[] = {
29081 (char *) "val", NULL
29082 };
29083
29084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29085 ecode1 = SWIG_AsVal_long(obj0, &val1);
29086 if (!SWIG_IsOK(ecode1)) {
29087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29088 }
29089 arg1 = static_cast< long >(val1);
29090 {
29091 PyThreadState* __tstate = wxPyBeginAllowThreads();
29092 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29093 wxPyEndAllowThreads(__tstate);
29094 if (PyErr_Occurred()) SWIG_fail;
29095 }
29096 resultobj = SWIG_Py_Void();
29097 return resultobj;
29098 fail:
29099 return NULL;
29100 }
29101
29102
29103 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29104 PyObject *resultobj = 0;
29105 long arg1 ;
29106 long val1 ;
29107 int ecode1 = 0 ;
29108 PyObject * obj0 = 0 ;
29109 char * kwnames[] = {
29110 (char *) "val", NULL
29111 };
29112
29113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29114 ecode1 = SWIG_AsVal_long(obj0, &val1);
29115 if (!SWIG_IsOK(ecode1)) {
29116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29117 }
29118 arg1 = static_cast< long >(val1);
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 wxPyApp::SetMacExitMenuItemId(arg1);
29122 wxPyEndAllowThreads(__tstate);
29123 if (PyErr_Occurred()) SWIG_fail;
29124 }
29125 resultobj = SWIG_Py_Void();
29126 return resultobj;
29127 fail:
29128 return NULL;
29129 }
29130
29131
29132 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29133 PyObject *resultobj = 0;
29134 wxString *arg1 = 0 ;
29135 bool temp1 = false ;
29136 PyObject * obj0 = 0 ;
29137 char * kwnames[] = {
29138 (char *) "val", NULL
29139 };
29140
29141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29142 {
29143 arg1 = wxString_in_helper(obj0);
29144 if (arg1 == NULL) SWIG_fail;
29145 temp1 = true;
29146 }
29147 {
29148 PyThreadState* __tstate = wxPyBeginAllowThreads();
29149 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29150 wxPyEndAllowThreads(__tstate);
29151 if (PyErr_Occurred()) SWIG_fail;
29152 }
29153 resultobj = SWIG_Py_Void();
29154 {
29155 if (temp1)
29156 delete arg1;
29157 }
29158 return resultobj;
29159 fail:
29160 {
29161 if (temp1)
29162 delete arg1;
29163 }
29164 return NULL;
29165 }
29166
29167
29168 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29169 PyObject *resultobj = 0;
29170 wxPyApp *arg1 = (wxPyApp *) 0 ;
29171 void *argp1 = 0 ;
29172 int res1 = 0 ;
29173 PyObject *swig_obj[1] ;
29174
29175 if (!args) SWIG_fail;
29176 swig_obj[0] = args;
29177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29178 if (!SWIG_IsOK(res1)) {
29179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29180 }
29181 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29182 {
29183 PyThreadState* __tstate = wxPyBeginAllowThreads();
29184 (arg1)->_BootstrapApp();
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_Py_Void();
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29196 PyObject *resultobj = 0;
29197 int result;
29198
29199 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (int)wxPyApp_GetComCtl32Version();
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 resultobj = SWIG_From_int(static_cast< int >(result));
29207 return resultobj;
29208 fail:
29209 return NULL;
29210 }
29211
29212
29213 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29214 PyObject *resultobj = 0;
29215 bool result;
29216
29217 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 result = (bool)wxPyApp_IsDisplayAvailable();
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 {
29225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29226 }
29227 return resultobj;
29228 fail:
29229 return NULL;
29230 }
29231
29232
29233 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29234 PyObject *obj;
29235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29236 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29237 return SWIG_Py_Void();
29238 }
29239
29240 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29241 return SWIG_Python_InitShadowInstance(args);
29242 }
29243
29244 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29245 PyObject *resultobj = 0;
29246
29247 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29248 {
29249 PyThreadState* __tstate = wxPyBeginAllowThreads();
29250 wxExit();
29251 wxPyEndAllowThreads(__tstate);
29252 if (PyErr_Occurred()) SWIG_fail;
29253 }
29254 resultobj = SWIG_Py_Void();
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29262 PyObject *resultobj = 0;
29263 bool result;
29264
29265 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (bool)wxYield();
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 {
29273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29274 }
29275 return resultobj;
29276 fail:
29277 return NULL;
29278 }
29279
29280
29281 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29282 PyObject *resultobj = 0;
29283 bool result;
29284
29285 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29286 {
29287 PyThreadState* __tstate = wxPyBeginAllowThreads();
29288 result = (bool)wxYieldIfNeeded();
29289 wxPyEndAllowThreads(__tstate);
29290 if (PyErr_Occurred()) SWIG_fail;
29291 }
29292 {
29293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29294 }
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29302 PyObject *resultobj = 0;
29303 wxWindow *arg1 = (wxWindow *) NULL ;
29304 bool arg2 = (bool) false ;
29305 bool result;
29306 void *argp1 = 0 ;
29307 int res1 = 0 ;
29308 bool val2 ;
29309 int ecode2 = 0 ;
29310 PyObject * obj0 = 0 ;
29311 PyObject * obj1 = 0 ;
29312 char * kwnames[] = {
29313 (char *) "win",(char *) "onlyIfNeeded", NULL
29314 };
29315
29316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29317 if (obj0) {
29318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29319 if (!SWIG_IsOK(res1)) {
29320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29321 }
29322 arg1 = reinterpret_cast< wxWindow * >(argp1);
29323 }
29324 if (obj1) {
29325 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29326 if (!SWIG_IsOK(ecode2)) {
29327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29328 }
29329 arg2 = static_cast< bool >(val2);
29330 }
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (bool)wxSafeYield(arg1,arg2);
29334 wxPyEndAllowThreads(__tstate);
29335 if (PyErr_Occurred()) SWIG_fail;
29336 }
29337 {
29338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29339 }
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347 PyObject *resultobj = 0;
29348
29349 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 wxWakeUpIdle();
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_Py_Void();
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29366 wxEvent *arg2 = 0 ;
29367 void *argp1 = 0 ;
29368 int res1 = 0 ;
29369 void *argp2 = 0 ;
29370 int res2 = 0 ;
29371 PyObject * obj0 = 0 ;
29372 PyObject * obj1 = 0 ;
29373 char * kwnames[] = {
29374 (char *) "dest",(char *) "event", NULL
29375 };
29376
29377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29379 if (!SWIG_IsOK(res1)) {
29380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29381 }
29382 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29383 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29384 if (!SWIG_IsOK(res2)) {
29385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29386 }
29387 if (!argp2) {
29388 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29389 }
29390 arg2 = reinterpret_cast< wxEvent * >(argp2);
29391 {
29392 PyThreadState* __tstate = wxPyBeginAllowThreads();
29393 wxPostEvent(arg1,*arg2);
29394 wxPyEndAllowThreads(__tstate);
29395 if (PyErr_Occurred()) SWIG_fail;
29396 }
29397 resultobj = SWIG_Py_Void();
29398 return resultobj;
29399 fail:
29400 return NULL;
29401 }
29402
29403
29404 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29405 PyObject *resultobj = 0;
29406
29407 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29408 {
29409 PyThreadState* __tstate = wxPyBeginAllowThreads();
29410 wxApp_CleanUp();
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 resultobj = SWIG_Py_Void();
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29422 PyObject *resultobj = 0;
29423 wxPyApp *result = 0 ;
29424
29425 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (wxPyApp *)wxPyGetApp();
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 {
29433 resultobj = wxPyMake_wxObject(result, 0);
29434 }
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj = 0;
29443 char *arg1 = (char *) 0 ;
29444 int res1 ;
29445 char *buf1 = 0 ;
29446 int alloc1 = 0 ;
29447 PyObject * obj0 = 0 ;
29448 char * kwnames[] = {
29449 (char *) "encoding", NULL
29450 };
29451
29452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29453 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29454 if (!SWIG_IsOK(res1)) {
29455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29456 }
29457 arg1 = buf1;
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 wxSetDefaultPyEncoding((char const *)arg1);
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 resultobj = SWIG_Py_Void();
29465 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29466 return resultobj;
29467 fail:
29468 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 char *result = 0 ;
29476
29477 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29478 {
29479 PyThreadState* __tstate = wxPyBeginAllowThreads();
29480 result = (char *)wxGetDefaultPyEncoding();
29481 wxPyEndAllowThreads(__tstate);
29482 if (PyErr_Occurred()) SWIG_fail;
29483 }
29484 resultobj = SWIG_FromCharPtr(result);
29485 return resultobj;
29486 fail:
29487 return NULL;
29488 }
29489
29490
29491 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29492 PyObject *resultobj = 0;
29493 wxEventLoop *result = 0 ;
29494
29495 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29496 {
29497 PyThreadState* __tstate = wxPyBeginAllowThreads();
29498 result = (wxEventLoop *)new wxEventLoop();
29499 wxPyEndAllowThreads(__tstate);
29500 if (PyErr_Occurred()) SWIG_fail;
29501 }
29502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29510 PyObject *resultobj = 0;
29511 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29512 void *argp1 = 0 ;
29513 int res1 = 0 ;
29514 PyObject *swig_obj[1] ;
29515
29516 if (!args) SWIG_fail;
29517 swig_obj[0] = args;
29518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29519 if (!SWIG_IsOK(res1)) {
29520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29521 }
29522 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29523 {
29524 PyThreadState* __tstate = wxPyBeginAllowThreads();
29525 delete arg1;
29526
29527 wxPyEndAllowThreads(__tstate);
29528 if (PyErr_Occurred()) SWIG_fail;
29529 }
29530 resultobj = SWIG_Py_Void();
29531 return resultobj;
29532 fail:
29533 return NULL;
29534 }
29535
29536
29537 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29538 PyObject *resultobj = 0;
29539 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29540 int result;
29541 void *argp1 = 0 ;
29542 int res1 = 0 ;
29543 PyObject *swig_obj[1] ;
29544
29545 if (!args) SWIG_fail;
29546 swig_obj[0] = args;
29547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29548 if (!SWIG_IsOK(res1)) {
29549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29550 }
29551 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29552 {
29553 PyThreadState* __tstate = wxPyBeginAllowThreads();
29554 result = (int)(arg1)->Run();
29555 wxPyEndAllowThreads(__tstate);
29556 if (PyErr_Occurred()) SWIG_fail;
29557 }
29558 resultobj = SWIG_From_int(static_cast< int >(result));
29559 return resultobj;
29560 fail:
29561 return NULL;
29562 }
29563
29564
29565 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29566 PyObject *resultobj = 0;
29567 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29568 int arg2 = (int) 0 ;
29569 void *argp1 = 0 ;
29570 int res1 = 0 ;
29571 int val2 ;
29572 int ecode2 = 0 ;
29573 PyObject * obj0 = 0 ;
29574 PyObject * obj1 = 0 ;
29575 char * kwnames[] = {
29576 (char *) "self",(char *) "rc", NULL
29577 };
29578
29579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29581 if (!SWIG_IsOK(res1)) {
29582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29583 }
29584 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29585 if (obj1) {
29586 ecode2 = SWIG_AsVal_int(obj1, &val2);
29587 if (!SWIG_IsOK(ecode2)) {
29588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29589 }
29590 arg2 = static_cast< int >(val2);
29591 }
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 (arg1)->Exit(arg2);
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 resultobj = SWIG_Py_Void();
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29606 PyObject *resultobj = 0;
29607 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29608 bool result;
29609 void *argp1 = 0 ;
29610 int res1 = 0 ;
29611 PyObject *swig_obj[1] ;
29612
29613 if (!args) SWIG_fail;
29614 swig_obj[0] = args;
29615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29616 if (!SWIG_IsOK(res1)) {
29617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29618 }
29619 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (bool)((wxEventLoop const *)arg1)->Pending();
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 {
29627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29628 }
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29636 PyObject *resultobj = 0;
29637 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29638 bool result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 PyObject *swig_obj[1] ;
29642
29643 if (!args) SWIG_fail;
29644 swig_obj[0] = args;
29645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29648 }
29649 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = (bool)(arg1)->Dispatch();
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 {
29657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29658 }
29659 return resultobj;
29660 fail:
29661 return NULL;
29662 }
29663
29664
29665 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29666 PyObject *resultobj = 0;
29667 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29668 bool result;
29669 void *argp1 = 0 ;
29670 int res1 = 0 ;
29671 PyObject *swig_obj[1] ;
29672
29673 if (!args) SWIG_fail;
29674 swig_obj[0] = args;
29675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29676 if (!SWIG_IsOK(res1)) {
29677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29678 }
29679 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29680 {
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29683 wxPyEndAllowThreads(__tstate);
29684 if (PyErr_Occurred()) SWIG_fail;
29685 }
29686 {
29687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29688 }
29689 return resultobj;
29690 fail:
29691 return NULL;
29692 }
29693
29694
29695 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29696 PyObject *resultobj = 0;
29697 wxEventLoop *result = 0 ;
29698
29699 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29700 {
29701 PyThreadState* __tstate = wxPyBeginAllowThreads();
29702 result = (wxEventLoop *)wxEventLoop::GetActive();
29703 wxPyEndAllowThreads(__tstate);
29704 if (PyErr_Occurred()) SWIG_fail;
29705 }
29706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29707 return resultobj;
29708 fail:
29709 return NULL;
29710 }
29711
29712
29713 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29714 PyObject *resultobj = 0;
29715 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29716 void *argp1 = 0 ;
29717 int res1 = 0 ;
29718 PyObject * obj0 = 0 ;
29719 char * kwnames[] = {
29720 (char *) "loop", NULL
29721 };
29722
29723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29725 if (!SWIG_IsOK(res1)) {
29726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29727 }
29728 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29729 {
29730 PyThreadState* __tstate = wxPyBeginAllowThreads();
29731 wxEventLoop::SetActive(arg1);
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 resultobj = SWIG_Py_Void();
29736 return resultobj;
29737 fail:
29738 return NULL;
29739 }
29740
29741
29742 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29743 PyObject *obj;
29744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29745 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29746 return SWIG_Py_Void();
29747 }
29748
29749 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29750 return SWIG_Python_InitShadowInstance(args);
29751 }
29752
29753 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29754 PyObject *resultobj = 0;
29755 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29756 wxEventLoopActivator *result = 0 ;
29757 void *argp1 = 0 ;
29758 int res1 = 0 ;
29759 PyObject * obj0 = 0 ;
29760 char * kwnames[] = {
29761 (char *) "evtLoop", NULL
29762 };
29763
29764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29766 if (!SWIG_IsOK(res1)) {
29767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29768 }
29769 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29770 {
29771 PyThreadState* __tstate = wxPyBeginAllowThreads();
29772 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29773 wxPyEndAllowThreads(__tstate);
29774 if (PyErr_Occurred()) SWIG_fail;
29775 }
29776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29777 return resultobj;
29778 fail:
29779 return NULL;
29780 }
29781
29782
29783 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29784 PyObject *resultobj = 0;
29785 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29786 void *argp1 = 0 ;
29787 int res1 = 0 ;
29788 PyObject *swig_obj[1] ;
29789
29790 if (!args) SWIG_fail;
29791 swig_obj[0] = args;
29792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29793 if (!SWIG_IsOK(res1)) {
29794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29795 }
29796 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 delete arg1;
29800
29801 wxPyEndAllowThreads(__tstate);
29802 if (PyErr_Occurred()) SWIG_fail;
29803 }
29804 resultobj = SWIG_Py_Void();
29805 return resultobj;
29806 fail:
29807 return NULL;
29808 }
29809
29810
29811 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29812 PyObject *obj;
29813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29814 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29815 return SWIG_Py_Void();
29816 }
29817
29818 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29819 return SWIG_Python_InitShadowInstance(args);
29820 }
29821
29822 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29823 PyObject *resultobj = 0;
29824 int arg1 = (int) 0 ;
29825 int arg2 = (int) 0 ;
29826 int arg3 = (int) 0 ;
29827 wxAcceleratorEntry *result = 0 ;
29828 int val1 ;
29829 int ecode1 = 0 ;
29830 int val2 ;
29831 int ecode2 = 0 ;
29832 int val3 ;
29833 int ecode3 = 0 ;
29834 PyObject * obj0 = 0 ;
29835 PyObject * obj1 = 0 ;
29836 PyObject * obj2 = 0 ;
29837 char * kwnames[] = {
29838 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29839 };
29840
29841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29842 if (obj0) {
29843 ecode1 = SWIG_AsVal_int(obj0, &val1);
29844 if (!SWIG_IsOK(ecode1)) {
29845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29846 }
29847 arg1 = static_cast< int >(val1);
29848 }
29849 if (obj1) {
29850 ecode2 = SWIG_AsVal_int(obj1, &val2);
29851 if (!SWIG_IsOK(ecode2)) {
29852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29853 }
29854 arg2 = static_cast< int >(val2);
29855 }
29856 if (obj2) {
29857 ecode3 = SWIG_AsVal_int(obj2, &val3);
29858 if (!SWIG_IsOK(ecode3)) {
29859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29860 }
29861 arg3 = static_cast< int >(val3);
29862 }
29863 {
29864 PyThreadState* __tstate = wxPyBeginAllowThreads();
29865 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29866 wxPyEndAllowThreads(__tstate);
29867 if (PyErr_Occurred()) SWIG_fail;
29868 }
29869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29870 return resultobj;
29871 fail:
29872 return NULL;
29873 }
29874
29875
29876 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29877 PyObject *resultobj = 0;
29878 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 PyObject *swig_obj[1] ;
29882
29883 if (!args) SWIG_fail;
29884 swig_obj[0] = args;
29885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29886 if (!SWIG_IsOK(res1)) {
29887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29888 }
29889 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29890 {
29891 PyThreadState* __tstate = wxPyBeginAllowThreads();
29892 delete arg1;
29893
29894 wxPyEndAllowThreads(__tstate);
29895 if (PyErr_Occurred()) SWIG_fail;
29896 }
29897 resultobj = SWIG_Py_Void();
29898 return resultobj;
29899 fail:
29900 return NULL;
29901 }
29902
29903
29904 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29905 PyObject *resultobj = 0;
29906 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29907 int arg2 ;
29908 int arg3 ;
29909 int arg4 ;
29910 void *argp1 = 0 ;
29911 int res1 = 0 ;
29912 int val2 ;
29913 int ecode2 = 0 ;
29914 int val3 ;
29915 int ecode3 = 0 ;
29916 int val4 ;
29917 int ecode4 = 0 ;
29918 PyObject * obj0 = 0 ;
29919 PyObject * obj1 = 0 ;
29920 PyObject * obj2 = 0 ;
29921 PyObject * obj3 = 0 ;
29922 char * kwnames[] = {
29923 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29924 };
29925
29926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29928 if (!SWIG_IsOK(res1)) {
29929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29930 }
29931 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29932 ecode2 = SWIG_AsVal_int(obj1, &val2);
29933 if (!SWIG_IsOK(ecode2)) {
29934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29935 }
29936 arg2 = static_cast< int >(val2);
29937 ecode3 = SWIG_AsVal_int(obj2, &val3);
29938 if (!SWIG_IsOK(ecode3)) {
29939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29940 }
29941 arg3 = static_cast< int >(val3);
29942 ecode4 = SWIG_AsVal_int(obj3, &val4);
29943 if (!SWIG_IsOK(ecode4)) {
29944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29945 }
29946 arg4 = static_cast< int >(val4);
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 (arg1)->Set(arg2,arg3,arg4);
29950 wxPyEndAllowThreads(__tstate);
29951 if (PyErr_Occurred()) SWIG_fail;
29952 }
29953 resultobj = SWIG_Py_Void();
29954 return resultobj;
29955 fail:
29956 return NULL;
29957 }
29958
29959
29960 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29961 PyObject *resultobj = 0;
29962 wxString *arg1 = 0 ;
29963 wxAcceleratorEntry *result = 0 ;
29964 bool temp1 = false ;
29965 PyObject * obj0 = 0 ;
29966 char * kwnames[] = {
29967 (char *) "str", NULL
29968 };
29969
29970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29971 {
29972 arg1 = wxString_in_helper(obj0);
29973 if (arg1 == NULL) SWIG_fail;
29974 temp1 = true;
29975 }
29976 {
29977 PyThreadState* __tstate = wxPyBeginAllowThreads();
29978 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29983 {
29984 if (temp1)
29985 delete arg1;
29986 }
29987 return resultobj;
29988 fail:
29989 {
29990 if (temp1)
29991 delete arg1;
29992 }
29993 return NULL;
29994 }
29995
29996
29997 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29998 PyObject *resultobj = 0;
29999 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30000 int result;
30001 void *argp1 = 0 ;
30002 int res1 = 0 ;
30003 PyObject *swig_obj[1] ;
30004
30005 if (!args) SWIG_fail;
30006 swig_obj[0] = args;
30007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30008 if (!SWIG_IsOK(res1)) {
30009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30010 }
30011 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30012 {
30013 PyThreadState* __tstate = wxPyBeginAllowThreads();
30014 result = (int)(arg1)->GetFlags();
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 resultobj = SWIG_From_int(static_cast< int >(result));
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30026 PyObject *resultobj = 0;
30027 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30028 int result;
30029 void *argp1 = 0 ;
30030 int res1 = 0 ;
30031 PyObject *swig_obj[1] ;
30032
30033 if (!args) SWIG_fail;
30034 swig_obj[0] = args;
30035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30036 if (!SWIG_IsOK(res1)) {
30037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30038 }
30039 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 result = (int)(arg1)->GetKeyCode();
30043 wxPyEndAllowThreads(__tstate);
30044 if (PyErr_Occurred()) SWIG_fail;
30045 }
30046 resultobj = SWIG_From_int(static_cast< int >(result));
30047 return resultobj;
30048 fail:
30049 return NULL;
30050 }
30051
30052
30053 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30054 PyObject *resultobj = 0;
30055 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30056 int result;
30057 void *argp1 = 0 ;
30058 int res1 = 0 ;
30059 PyObject *swig_obj[1] ;
30060
30061 if (!args) SWIG_fail;
30062 swig_obj[0] = args;
30063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30064 if (!SWIG_IsOK(res1)) {
30065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30066 }
30067 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 result = (int)(arg1)->GetCommand();
30071 wxPyEndAllowThreads(__tstate);
30072 if (PyErr_Occurred()) SWIG_fail;
30073 }
30074 resultobj = SWIG_From_int(static_cast< int >(result));
30075 return resultobj;
30076 fail:
30077 return NULL;
30078 }
30079
30080
30081 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30082 PyObject *resultobj = 0;
30083 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30084 bool result;
30085 void *argp1 = 0 ;
30086 int res1 = 0 ;
30087 PyObject *swig_obj[1] ;
30088
30089 if (!args) SWIG_fail;
30090 swig_obj[0] = args;
30091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30092 if (!SWIG_IsOK(res1)) {
30093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30094 }
30095 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30096 {
30097 PyThreadState* __tstate = wxPyBeginAllowThreads();
30098 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 {
30103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30104 }
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30112 PyObject *resultobj = 0;
30113 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30114 wxString result;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 PyObject *swig_obj[1] ;
30118
30119 if (!args) SWIG_fail;
30120 swig_obj[0] = args;
30121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30122 if (!SWIG_IsOK(res1)) {
30123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30124 }
30125 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30126 {
30127 PyThreadState* __tstate = wxPyBeginAllowThreads();
30128 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30129 wxPyEndAllowThreads(__tstate);
30130 if (PyErr_Occurred()) SWIG_fail;
30131 }
30132 {
30133 #if wxUSE_UNICODE
30134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30135 #else
30136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30137 #endif
30138 }
30139 return resultobj;
30140 fail:
30141 return NULL;
30142 }
30143
30144
30145 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30146 PyObject *resultobj = 0;
30147 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30148 wxString *arg2 = 0 ;
30149 bool result;
30150 void *argp1 = 0 ;
30151 int res1 = 0 ;
30152 bool temp2 = false ;
30153 PyObject * obj0 = 0 ;
30154 PyObject * obj1 = 0 ;
30155 char * kwnames[] = {
30156 (char *) "self",(char *) "str", NULL
30157 };
30158
30159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30161 if (!SWIG_IsOK(res1)) {
30162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30163 }
30164 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30165 {
30166 arg2 = wxString_in_helper(obj1);
30167 if (arg2 == NULL) SWIG_fail;
30168 temp2 = true;
30169 }
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30173 wxPyEndAllowThreads(__tstate);
30174 if (PyErr_Occurred()) SWIG_fail;
30175 }
30176 {
30177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30178 }
30179 {
30180 if (temp2)
30181 delete arg2;
30182 }
30183 return resultobj;
30184 fail:
30185 {
30186 if (temp2)
30187 delete arg2;
30188 }
30189 return NULL;
30190 }
30191
30192
30193 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30194 PyObject *obj;
30195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30196 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30197 return SWIG_Py_Void();
30198 }
30199
30200 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30201 return SWIG_Python_InitShadowInstance(args);
30202 }
30203
30204 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30205 PyObject *resultobj = 0;
30206 int arg1 ;
30207 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30208 wxAcceleratorTable *result = 0 ;
30209 PyObject * obj0 = 0 ;
30210 char * kwnames[] = {
30211 (char *) "n", NULL
30212 };
30213
30214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30215 {
30216 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30217 if (arg2) arg1 = PyList_Size(obj0);
30218 else arg1 = 0;
30219 }
30220 {
30221 PyThreadState* __tstate = wxPyBeginAllowThreads();
30222 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30234 PyObject *resultobj = 0;
30235 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30236 void *argp1 = 0 ;
30237 int res1 = 0 ;
30238 PyObject *swig_obj[1] ;
30239
30240 if (!args) SWIG_fail;
30241 swig_obj[0] = args;
30242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30243 if (!SWIG_IsOK(res1)) {
30244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30245 }
30246 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30247 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 delete arg1;
30250
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 resultobj = SWIG_Py_Void();
30255 return resultobj;
30256 fail:
30257 return NULL;
30258 }
30259
30260
30261 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30262 PyObject *resultobj = 0;
30263 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30264 bool result;
30265 void *argp1 = 0 ;
30266 int res1 = 0 ;
30267 PyObject *swig_obj[1] ;
30268
30269 if (!args) SWIG_fail;
30270 swig_obj[0] = args;
30271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30272 if (!SWIG_IsOK(res1)) {
30273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30274 }
30275 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30276 {
30277 PyThreadState* __tstate = wxPyBeginAllowThreads();
30278 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30279 wxPyEndAllowThreads(__tstate);
30280 if (PyErr_Occurred()) SWIG_fail;
30281 }
30282 {
30283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30284 }
30285 return resultobj;
30286 fail:
30287 return NULL;
30288 }
30289
30290
30291 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30292 PyObject *obj;
30293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30294 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30295 return SWIG_Py_Void();
30296 }
30297
30298 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30299 return SWIG_Python_InitShadowInstance(args);
30300 }
30301
30302 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30303 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30304 return 1;
30305 }
30306
30307
30308 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30309 PyObject *pyobj = 0;
30310
30311 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30312 return pyobj;
30313 }
30314
30315
30316 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30317 PyObject *resultobj = 0;
30318 wxString *arg1 = 0 ;
30319 wxAcceleratorEntry *result = 0 ;
30320 bool temp1 = false ;
30321 PyObject * obj0 = 0 ;
30322 char * kwnames[] = {
30323 (char *) "label", NULL
30324 };
30325
30326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30327 {
30328 arg1 = wxString_in_helper(obj0);
30329 if (arg1 == NULL) SWIG_fail;
30330 temp1 = true;
30331 }
30332 {
30333 PyThreadState* __tstate = wxPyBeginAllowThreads();
30334 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30335 wxPyEndAllowThreads(__tstate);
30336 if (PyErr_Occurred()) SWIG_fail;
30337 }
30338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30339 {
30340 if (temp1)
30341 delete arg1;
30342 }
30343 return resultobj;
30344 fail:
30345 {
30346 if (temp1)
30347 delete arg1;
30348 }
30349 return NULL;
30350 }
30351
30352
30353 SWIGINTERN int PanelNameStr_set(PyObject *) {
30354 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30355 return 1;
30356 }
30357
30358
30359 SWIGINTERN PyObject *PanelNameStr_get(void) {
30360 PyObject *pyobj = 0;
30361
30362 {
30363 #if wxUSE_UNICODE
30364 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30365 #else
30366 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30367 #endif
30368 }
30369 return pyobj;
30370 }
30371
30372
30373 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30374 PyObject *resultobj = 0;
30375 wxVisualAttributes *result = 0 ;
30376
30377 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 result = (wxVisualAttributes *)new_wxVisualAttributes();
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30385 return resultobj;
30386 fail:
30387 return NULL;
30388 }
30389
30390
30391 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30392 PyObject *resultobj = 0;
30393 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30394 void *argp1 = 0 ;
30395 int res1 = 0 ;
30396 PyObject *swig_obj[1] ;
30397
30398 if (!args) SWIG_fail;
30399 swig_obj[0] = args;
30400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30401 if (!SWIG_IsOK(res1)) {
30402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30403 }
30404 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30405 {
30406 PyThreadState* __tstate = wxPyBeginAllowThreads();
30407 delete_wxVisualAttributes(arg1);
30408
30409 wxPyEndAllowThreads(__tstate);
30410 if (PyErr_Occurred()) SWIG_fail;
30411 }
30412 resultobj = SWIG_Py_Void();
30413 return resultobj;
30414 fail:
30415 return NULL;
30416 }
30417
30418
30419 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30420 PyObject *resultobj = 0;
30421 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30422 wxFont *arg2 = (wxFont *) 0 ;
30423 void *argp1 = 0 ;
30424 int res1 = 0 ;
30425 void *argp2 = 0 ;
30426 int res2 = 0 ;
30427 PyObject *swig_obj[2] ;
30428
30429 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30431 if (!SWIG_IsOK(res1)) {
30432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30433 }
30434 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30435 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30436 if (!SWIG_IsOK(res2)) {
30437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30438 }
30439 arg2 = reinterpret_cast< wxFont * >(argp2);
30440 if (arg1) (arg1)->font = *arg2;
30441
30442 resultobj = SWIG_Py_Void();
30443 return resultobj;
30444 fail:
30445 return NULL;
30446 }
30447
30448
30449 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30450 PyObject *resultobj = 0;
30451 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30452 wxFont *result = 0 ;
30453 void *argp1 = 0 ;
30454 int res1 = 0 ;
30455 PyObject *swig_obj[1] ;
30456
30457 if (!args) SWIG_fail;
30458 swig_obj[0] = args;
30459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30460 if (!SWIG_IsOK(res1)) {
30461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30462 }
30463 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30464 result = (wxFont *)& ((arg1)->font);
30465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30473 PyObject *resultobj = 0;
30474 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30475 wxColour *arg2 = (wxColour *) 0 ;
30476 void *argp1 = 0 ;
30477 int res1 = 0 ;
30478 void *argp2 = 0 ;
30479 int res2 = 0 ;
30480 PyObject *swig_obj[2] ;
30481
30482 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30484 if (!SWIG_IsOK(res1)) {
30485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30486 }
30487 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30488 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30489 if (!SWIG_IsOK(res2)) {
30490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30491 }
30492 arg2 = reinterpret_cast< wxColour * >(argp2);
30493 if (arg1) (arg1)->colFg = *arg2;
30494
30495 resultobj = SWIG_Py_Void();
30496 return resultobj;
30497 fail:
30498 return NULL;
30499 }
30500
30501
30502 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30503 PyObject *resultobj = 0;
30504 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30505 wxColour *result = 0 ;
30506 void *argp1 = 0 ;
30507 int res1 = 0 ;
30508 PyObject *swig_obj[1] ;
30509
30510 if (!args) SWIG_fail;
30511 swig_obj[0] = args;
30512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30513 if (!SWIG_IsOK(res1)) {
30514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30515 }
30516 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30517 result = (wxColour *)& ((arg1)->colFg);
30518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30526 PyObject *resultobj = 0;
30527 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30528 wxColour *arg2 = (wxColour *) 0 ;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 void *argp2 = 0 ;
30532 int res2 = 0 ;
30533 PyObject *swig_obj[2] ;
30534
30535 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30539 }
30540 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30541 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30542 if (!SWIG_IsOK(res2)) {
30543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30544 }
30545 arg2 = reinterpret_cast< wxColour * >(argp2);
30546 if (arg1) (arg1)->colBg = *arg2;
30547
30548 resultobj = SWIG_Py_Void();
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30558 wxColour *result = 0 ;
30559 void *argp1 = 0 ;
30560 int res1 = 0 ;
30561 PyObject *swig_obj[1] ;
30562
30563 if (!args) SWIG_fail;
30564 swig_obj[0] = args;
30565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30568 }
30569 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30570 result = (wxColour *)& ((arg1)->colBg);
30571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30579 PyObject *obj;
30580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30581 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30582 return SWIG_Py_Void();
30583 }
30584
30585 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 return SWIG_Python_InitShadowInstance(args);
30587 }
30588
30589 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30590 PyObject *resultobj = 0;
30591 wxWindow *arg1 = (wxWindow *) 0 ;
30592 int arg2 = (int) (int)-1 ;
30593 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30594 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30595 wxSize const &arg4_defvalue = wxDefaultSize ;
30596 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30597 long arg5 = (long) 0 ;
30598 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30599 wxString *arg6 = (wxString *) &arg6_defvalue ;
30600 wxWindow *result = 0 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 int val2 ;
30604 int ecode2 = 0 ;
30605 wxPoint temp3 ;
30606 wxSize temp4 ;
30607 long val5 ;
30608 int ecode5 = 0 ;
30609 bool temp6 = false ;
30610 PyObject * obj0 = 0 ;
30611 PyObject * obj1 = 0 ;
30612 PyObject * obj2 = 0 ;
30613 PyObject * obj3 = 0 ;
30614 PyObject * obj4 = 0 ;
30615 PyObject * obj5 = 0 ;
30616 char * kwnames[] = {
30617 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30618 };
30619
30620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30622 if (!SWIG_IsOK(res1)) {
30623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30624 }
30625 arg1 = reinterpret_cast< wxWindow * >(argp1);
30626 if (obj1) {
30627 ecode2 = SWIG_AsVal_int(obj1, &val2);
30628 if (!SWIG_IsOK(ecode2)) {
30629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30630 }
30631 arg2 = static_cast< int >(val2);
30632 }
30633 if (obj2) {
30634 {
30635 arg3 = &temp3;
30636 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30637 }
30638 }
30639 if (obj3) {
30640 {
30641 arg4 = &temp4;
30642 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30643 }
30644 }
30645 if (obj4) {
30646 ecode5 = SWIG_AsVal_long(obj4, &val5);
30647 if (!SWIG_IsOK(ecode5)) {
30648 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30649 }
30650 arg5 = static_cast< long >(val5);
30651 }
30652 if (obj5) {
30653 {
30654 arg6 = wxString_in_helper(obj5);
30655 if (arg6 == NULL) SWIG_fail;
30656 temp6 = true;
30657 }
30658 }
30659 {
30660 if (!wxPyCheckForApp()) SWIG_fail;
30661 PyThreadState* __tstate = wxPyBeginAllowThreads();
30662 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30663 wxPyEndAllowThreads(__tstate);
30664 if (PyErr_Occurred()) SWIG_fail;
30665 }
30666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30667 {
30668 if (temp6)
30669 delete arg6;
30670 }
30671 return resultobj;
30672 fail:
30673 {
30674 if (temp6)
30675 delete arg6;
30676 }
30677 return NULL;
30678 }
30679
30680
30681 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30682 PyObject *resultobj = 0;
30683 wxWindow *result = 0 ;
30684
30685 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30686 {
30687 if (!wxPyCheckForApp()) SWIG_fail;
30688 PyThreadState* __tstate = wxPyBeginAllowThreads();
30689 result = (wxWindow *)new wxWindow();
30690 wxPyEndAllowThreads(__tstate);
30691 if (PyErr_Occurred()) SWIG_fail;
30692 }
30693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30694 return resultobj;
30695 fail:
30696 return NULL;
30697 }
30698
30699
30700 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30701 PyObject *resultobj = 0;
30702 wxWindow *arg1 = (wxWindow *) 0 ;
30703 wxWindow *arg2 = (wxWindow *) 0 ;
30704 int arg3 = (int) (int)-1 ;
30705 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30706 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30707 wxSize const &arg5_defvalue = wxDefaultSize ;
30708 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30709 long arg6 = (long) 0 ;
30710 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30711 wxString *arg7 = (wxString *) &arg7_defvalue ;
30712 bool result;
30713 void *argp1 = 0 ;
30714 int res1 = 0 ;
30715 void *argp2 = 0 ;
30716 int res2 = 0 ;
30717 int val3 ;
30718 int ecode3 = 0 ;
30719 wxPoint temp4 ;
30720 wxSize temp5 ;
30721 long val6 ;
30722 int ecode6 = 0 ;
30723 bool temp7 = false ;
30724 PyObject * obj0 = 0 ;
30725 PyObject * obj1 = 0 ;
30726 PyObject * obj2 = 0 ;
30727 PyObject * obj3 = 0 ;
30728 PyObject * obj4 = 0 ;
30729 PyObject * obj5 = 0 ;
30730 PyObject * obj6 = 0 ;
30731 char * kwnames[] = {
30732 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30733 };
30734
30735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30737 if (!SWIG_IsOK(res1)) {
30738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30739 }
30740 arg1 = reinterpret_cast< wxWindow * >(argp1);
30741 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30742 if (!SWIG_IsOK(res2)) {
30743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30744 }
30745 arg2 = reinterpret_cast< wxWindow * >(argp2);
30746 if (obj2) {
30747 ecode3 = SWIG_AsVal_int(obj2, &val3);
30748 if (!SWIG_IsOK(ecode3)) {
30749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30750 }
30751 arg3 = static_cast< int >(val3);
30752 }
30753 if (obj3) {
30754 {
30755 arg4 = &temp4;
30756 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30757 }
30758 }
30759 if (obj4) {
30760 {
30761 arg5 = &temp5;
30762 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30763 }
30764 }
30765 if (obj5) {
30766 ecode6 = SWIG_AsVal_long(obj5, &val6);
30767 if (!SWIG_IsOK(ecode6)) {
30768 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30769 }
30770 arg6 = static_cast< long >(val6);
30771 }
30772 if (obj6) {
30773 {
30774 arg7 = wxString_in_helper(obj6);
30775 if (arg7 == NULL) SWIG_fail;
30776 temp7 = true;
30777 }
30778 }
30779 {
30780 PyThreadState* __tstate = wxPyBeginAllowThreads();
30781 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 {
30786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30787 }
30788 {
30789 if (temp7)
30790 delete arg7;
30791 }
30792 return resultobj;
30793 fail:
30794 {
30795 if (temp7)
30796 delete arg7;
30797 }
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj = 0;
30804 wxWindow *arg1 = (wxWindow *) 0 ;
30805 bool arg2 = (bool) false ;
30806 bool result;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 bool val2 ;
30810 int ecode2 = 0 ;
30811 PyObject * obj0 = 0 ;
30812 PyObject * obj1 = 0 ;
30813 char * kwnames[] = {
30814 (char *) "self",(char *) "force", NULL
30815 };
30816
30817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30819 if (!SWIG_IsOK(res1)) {
30820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30821 }
30822 arg1 = reinterpret_cast< wxWindow * >(argp1);
30823 if (obj1) {
30824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30825 if (!SWIG_IsOK(ecode2)) {
30826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30827 }
30828 arg2 = static_cast< bool >(val2);
30829 }
30830 {
30831 PyThreadState* __tstate = wxPyBeginAllowThreads();
30832 result = (bool)(arg1)->Close(arg2);
30833 wxPyEndAllowThreads(__tstate);
30834 if (PyErr_Occurred()) SWIG_fail;
30835 }
30836 {
30837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30838 }
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30846 PyObject *resultobj = 0;
30847 wxWindow *arg1 = (wxWindow *) 0 ;
30848 bool result;
30849 void *argp1 = 0 ;
30850 int res1 = 0 ;
30851 PyObject *swig_obj[1] ;
30852
30853 if (!args) SWIG_fail;
30854 swig_obj[0] = args;
30855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30856 if (!SWIG_IsOK(res1)) {
30857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30858 }
30859 arg1 = reinterpret_cast< wxWindow * >(argp1);
30860 {
30861 PyThreadState* __tstate = wxPyBeginAllowThreads();
30862 result = (bool)(arg1)->Destroy();
30863 wxPyEndAllowThreads(__tstate);
30864 if (PyErr_Occurred()) SWIG_fail;
30865 }
30866 {
30867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30868 }
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30876 PyObject *resultobj = 0;
30877 wxWindow *arg1 = (wxWindow *) 0 ;
30878 bool result;
30879 void *argp1 = 0 ;
30880 int res1 = 0 ;
30881 PyObject *swig_obj[1] ;
30882
30883 if (!args) SWIG_fail;
30884 swig_obj[0] = args;
30885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30886 if (!SWIG_IsOK(res1)) {
30887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30888 }
30889 arg1 = reinterpret_cast< wxWindow * >(argp1);
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 result = (bool)(arg1)->DestroyChildren();
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 {
30897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30898 }
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30906 PyObject *resultobj = 0;
30907 wxWindow *arg1 = (wxWindow *) 0 ;
30908 bool result;
30909 void *argp1 = 0 ;
30910 int res1 = 0 ;
30911 PyObject *swig_obj[1] ;
30912
30913 if (!args) SWIG_fail;
30914 swig_obj[0] = args;
30915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30916 if (!SWIG_IsOK(res1)) {
30917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30918 }
30919 arg1 = reinterpret_cast< wxWindow * >(argp1);
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30923 wxPyEndAllowThreads(__tstate);
30924 if (PyErr_Occurred()) SWIG_fail;
30925 }
30926 {
30927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30928 }
30929 return resultobj;
30930 fail:
30931 return NULL;
30932 }
30933
30934
30935 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30936 PyObject *resultobj = 0;
30937 wxWindow *arg1 = (wxWindow *) 0 ;
30938 wxString *arg2 = 0 ;
30939 void *argp1 = 0 ;
30940 int res1 = 0 ;
30941 bool temp2 = false ;
30942 PyObject * obj0 = 0 ;
30943 PyObject * obj1 = 0 ;
30944 char * kwnames[] = {
30945 (char *) "self",(char *) "label", NULL
30946 };
30947
30948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30950 if (!SWIG_IsOK(res1)) {
30951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30952 }
30953 arg1 = reinterpret_cast< wxWindow * >(argp1);
30954 {
30955 arg2 = wxString_in_helper(obj1);
30956 if (arg2 == NULL) SWIG_fail;
30957 temp2 = true;
30958 }
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 (arg1)->SetLabel((wxString const &)*arg2);
30962 wxPyEndAllowThreads(__tstate);
30963 if (PyErr_Occurred()) SWIG_fail;
30964 }
30965 resultobj = SWIG_Py_Void();
30966 {
30967 if (temp2)
30968 delete arg2;
30969 }
30970 return resultobj;
30971 fail:
30972 {
30973 if (temp2)
30974 delete arg2;
30975 }
30976 return NULL;
30977 }
30978
30979
30980 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30981 PyObject *resultobj = 0;
30982 wxWindow *arg1 = (wxWindow *) 0 ;
30983 wxString result;
30984 void *argp1 = 0 ;
30985 int res1 = 0 ;
30986 PyObject *swig_obj[1] ;
30987
30988 if (!args) SWIG_fail;
30989 swig_obj[0] = args;
30990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30991 if (!SWIG_IsOK(res1)) {
30992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30993 }
30994 arg1 = reinterpret_cast< wxWindow * >(argp1);
30995 {
30996 PyThreadState* __tstate = wxPyBeginAllowThreads();
30997 result = ((wxWindow const *)arg1)->GetLabel();
30998 wxPyEndAllowThreads(__tstate);
30999 if (PyErr_Occurred()) SWIG_fail;
31000 }
31001 {
31002 #if wxUSE_UNICODE
31003 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31004 #else
31005 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31006 #endif
31007 }
31008 return resultobj;
31009 fail:
31010 return NULL;
31011 }
31012
31013
31014 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31015 PyObject *resultobj = 0;
31016 wxWindow *arg1 = (wxWindow *) 0 ;
31017 wxString *arg2 = 0 ;
31018 void *argp1 = 0 ;
31019 int res1 = 0 ;
31020 bool temp2 = false ;
31021 PyObject * obj0 = 0 ;
31022 PyObject * obj1 = 0 ;
31023 char * kwnames[] = {
31024 (char *) "self",(char *) "name", NULL
31025 };
31026
31027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31029 if (!SWIG_IsOK(res1)) {
31030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31031 }
31032 arg1 = reinterpret_cast< wxWindow * >(argp1);
31033 {
31034 arg2 = wxString_in_helper(obj1);
31035 if (arg2 == NULL) SWIG_fail;
31036 temp2 = true;
31037 }
31038 {
31039 PyThreadState* __tstate = wxPyBeginAllowThreads();
31040 (arg1)->SetName((wxString const &)*arg2);
31041 wxPyEndAllowThreads(__tstate);
31042 if (PyErr_Occurred()) SWIG_fail;
31043 }
31044 resultobj = SWIG_Py_Void();
31045 {
31046 if (temp2)
31047 delete arg2;
31048 }
31049 return resultobj;
31050 fail:
31051 {
31052 if (temp2)
31053 delete arg2;
31054 }
31055 return NULL;
31056 }
31057
31058
31059 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31060 PyObject *resultobj = 0;
31061 wxWindow *arg1 = (wxWindow *) 0 ;
31062 wxString result;
31063 void *argp1 = 0 ;
31064 int res1 = 0 ;
31065 PyObject *swig_obj[1] ;
31066
31067 if (!args) SWIG_fail;
31068 swig_obj[0] = args;
31069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31070 if (!SWIG_IsOK(res1)) {
31071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31072 }
31073 arg1 = reinterpret_cast< wxWindow * >(argp1);
31074 {
31075 PyThreadState* __tstate = wxPyBeginAllowThreads();
31076 result = ((wxWindow const *)arg1)->GetName();
31077 wxPyEndAllowThreads(__tstate);
31078 if (PyErr_Occurred()) SWIG_fail;
31079 }
31080 {
31081 #if wxUSE_UNICODE
31082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31083 #else
31084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31085 #endif
31086 }
31087 return resultobj;
31088 fail:
31089 return NULL;
31090 }
31091
31092
31093 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31094 PyObject *resultobj = 0;
31095 wxWindow *arg1 = (wxWindow *) 0 ;
31096 wxWindowVariant arg2 ;
31097 void *argp1 = 0 ;
31098 int res1 = 0 ;
31099 int val2 ;
31100 int ecode2 = 0 ;
31101 PyObject * obj0 = 0 ;
31102 PyObject * obj1 = 0 ;
31103 char * kwnames[] = {
31104 (char *) "self",(char *) "variant", NULL
31105 };
31106
31107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31109 if (!SWIG_IsOK(res1)) {
31110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31111 }
31112 arg1 = reinterpret_cast< wxWindow * >(argp1);
31113 ecode2 = SWIG_AsVal_int(obj1, &val2);
31114 if (!SWIG_IsOK(ecode2)) {
31115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31116 }
31117 arg2 = static_cast< wxWindowVariant >(val2);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 (arg1)->SetWindowVariant(arg2);
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = SWIG_Py_Void();
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31132 PyObject *resultobj = 0;
31133 wxWindow *arg1 = (wxWindow *) 0 ;
31134 wxWindowVariant result;
31135 void *argp1 = 0 ;
31136 int res1 = 0 ;
31137 PyObject *swig_obj[1] ;
31138
31139 if (!args) SWIG_fail;
31140 swig_obj[0] = args;
31141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31142 if (!SWIG_IsOK(res1)) {
31143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31144 }
31145 arg1 = reinterpret_cast< wxWindow * >(argp1);
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31149 wxPyEndAllowThreads(__tstate);
31150 if (PyErr_Occurred()) SWIG_fail;
31151 }
31152 resultobj = SWIG_From_int(static_cast< int >(result));
31153 return resultobj;
31154 fail:
31155 return NULL;
31156 }
31157
31158
31159 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31160 PyObject *resultobj = 0;
31161 wxWindow *arg1 = (wxWindow *) 0 ;
31162 int arg2 ;
31163 void *argp1 = 0 ;
31164 int res1 = 0 ;
31165 int val2 ;
31166 int ecode2 = 0 ;
31167 PyObject * obj0 = 0 ;
31168 PyObject * obj1 = 0 ;
31169 char * kwnames[] = {
31170 (char *) "self",(char *) "winid", NULL
31171 };
31172
31173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31175 if (!SWIG_IsOK(res1)) {
31176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31177 }
31178 arg1 = reinterpret_cast< wxWindow * >(argp1);
31179 ecode2 = SWIG_AsVal_int(obj1, &val2);
31180 if (!SWIG_IsOK(ecode2)) {
31181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31182 }
31183 arg2 = static_cast< int >(val2);
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 (arg1)->SetId(arg2);
31187 wxPyEndAllowThreads(__tstate);
31188 if (PyErr_Occurred()) SWIG_fail;
31189 }
31190 resultobj = SWIG_Py_Void();
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31198 PyObject *resultobj = 0;
31199 wxWindow *arg1 = (wxWindow *) 0 ;
31200 int result;
31201 void *argp1 = 0 ;
31202 int res1 = 0 ;
31203 PyObject *swig_obj[1] ;
31204
31205 if (!args) SWIG_fail;
31206 swig_obj[0] = args;
31207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31208 if (!SWIG_IsOK(res1)) {
31209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31210 }
31211 arg1 = reinterpret_cast< wxWindow * >(argp1);
31212 {
31213 PyThreadState* __tstate = wxPyBeginAllowThreads();
31214 result = (int)((wxWindow const *)arg1)->GetId();
31215 wxPyEndAllowThreads(__tstate);
31216 if (PyErr_Occurred()) SWIG_fail;
31217 }
31218 resultobj = SWIG_From_int(static_cast< int >(result));
31219 return resultobj;
31220 fail:
31221 return NULL;
31222 }
31223
31224
31225 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31226 PyObject *resultobj = 0;
31227 int result;
31228
31229 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31230 {
31231 PyThreadState* __tstate = wxPyBeginAllowThreads();
31232 result = (int)wxWindow::NewControlId();
31233 wxPyEndAllowThreads(__tstate);
31234 if (PyErr_Occurred()) SWIG_fail;
31235 }
31236 resultobj = SWIG_From_int(static_cast< int >(result));
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31244 PyObject *resultobj = 0;
31245 int arg1 ;
31246 int result;
31247 int val1 ;
31248 int ecode1 = 0 ;
31249 PyObject * obj0 = 0 ;
31250 char * kwnames[] = {
31251 (char *) "winid", NULL
31252 };
31253
31254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31255 ecode1 = SWIG_AsVal_int(obj0, &val1);
31256 if (!SWIG_IsOK(ecode1)) {
31257 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31258 }
31259 arg1 = static_cast< int >(val1);
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 result = (int)wxWindow::NextControlId(arg1);
31263 wxPyEndAllowThreads(__tstate);
31264 if (PyErr_Occurred()) SWIG_fail;
31265 }
31266 resultobj = SWIG_From_int(static_cast< int >(result));
31267 return resultobj;
31268 fail:
31269 return NULL;
31270 }
31271
31272
31273 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31274 PyObject *resultobj = 0;
31275 int arg1 ;
31276 int result;
31277 int val1 ;
31278 int ecode1 = 0 ;
31279 PyObject * obj0 = 0 ;
31280 char * kwnames[] = {
31281 (char *) "winid", NULL
31282 };
31283
31284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31285 ecode1 = SWIG_AsVal_int(obj0, &val1);
31286 if (!SWIG_IsOK(ecode1)) {
31287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31288 }
31289 arg1 = static_cast< int >(val1);
31290 {
31291 PyThreadState* __tstate = wxPyBeginAllowThreads();
31292 result = (int)wxWindow::PrevControlId(arg1);
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 resultobj = SWIG_From_int(static_cast< int >(result));
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31304 PyObject *resultobj = 0;
31305 wxWindow *arg1 = (wxWindow *) 0 ;
31306 wxLayoutDirection result;
31307 void *argp1 = 0 ;
31308 int res1 = 0 ;
31309 PyObject *swig_obj[1] ;
31310
31311 if (!args) SWIG_fail;
31312 swig_obj[0] = args;
31313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31314 if (!SWIG_IsOK(res1)) {
31315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31316 }
31317 arg1 = reinterpret_cast< wxWindow * >(argp1);
31318 {
31319 PyThreadState* __tstate = wxPyBeginAllowThreads();
31320 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31321 wxPyEndAllowThreads(__tstate);
31322 if (PyErr_Occurred()) SWIG_fail;
31323 }
31324 resultobj = SWIG_From_int(static_cast< int >(result));
31325 return resultobj;
31326 fail:
31327 return NULL;
31328 }
31329
31330
31331 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31332 PyObject *resultobj = 0;
31333 wxWindow *arg1 = (wxWindow *) 0 ;
31334 wxLayoutDirection arg2 ;
31335 void *argp1 = 0 ;
31336 int res1 = 0 ;
31337 int val2 ;
31338 int ecode2 = 0 ;
31339 PyObject * obj0 = 0 ;
31340 PyObject * obj1 = 0 ;
31341 char * kwnames[] = {
31342 (char *) "self",(char *) "dir", NULL
31343 };
31344
31345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31347 if (!SWIG_IsOK(res1)) {
31348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31349 }
31350 arg1 = reinterpret_cast< wxWindow * >(argp1);
31351 ecode2 = SWIG_AsVal_int(obj1, &val2);
31352 if (!SWIG_IsOK(ecode2)) {
31353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31354 }
31355 arg2 = static_cast< wxLayoutDirection >(val2);
31356 {
31357 PyThreadState* __tstate = wxPyBeginAllowThreads();
31358 (arg1)->SetLayoutDirection(arg2);
31359 wxPyEndAllowThreads(__tstate);
31360 if (PyErr_Occurred()) SWIG_fail;
31361 }
31362 resultobj = SWIG_Py_Void();
31363 return resultobj;
31364 fail:
31365 return NULL;
31366 }
31367
31368
31369 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31370 PyObject *resultobj = 0;
31371 wxWindow *arg1 = (wxWindow *) 0 ;
31372 int arg2 ;
31373 int arg3 ;
31374 int arg4 ;
31375 int result;
31376 void *argp1 = 0 ;
31377 int res1 = 0 ;
31378 int val2 ;
31379 int ecode2 = 0 ;
31380 int val3 ;
31381 int ecode3 = 0 ;
31382 int val4 ;
31383 int ecode4 = 0 ;
31384 PyObject * obj0 = 0 ;
31385 PyObject * obj1 = 0 ;
31386 PyObject * obj2 = 0 ;
31387 PyObject * obj3 = 0 ;
31388 char * kwnames[] = {
31389 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31390 };
31391
31392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31394 if (!SWIG_IsOK(res1)) {
31395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31396 }
31397 arg1 = reinterpret_cast< wxWindow * >(argp1);
31398 ecode2 = SWIG_AsVal_int(obj1, &val2);
31399 if (!SWIG_IsOK(ecode2)) {
31400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31401 }
31402 arg2 = static_cast< int >(val2);
31403 ecode3 = SWIG_AsVal_int(obj2, &val3);
31404 if (!SWIG_IsOK(ecode3)) {
31405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31406 }
31407 arg3 = static_cast< int >(val3);
31408 ecode4 = SWIG_AsVal_int(obj3, &val4);
31409 if (!SWIG_IsOK(ecode4)) {
31410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31411 }
31412 arg4 = static_cast< int >(val4);
31413 {
31414 PyThreadState* __tstate = wxPyBeginAllowThreads();
31415 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31416 wxPyEndAllowThreads(__tstate);
31417 if (PyErr_Occurred()) SWIG_fail;
31418 }
31419 resultobj = SWIG_From_int(static_cast< int >(result));
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj = 0;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 wxSize *arg2 = 0 ;
31430 void *argp1 = 0 ;
31431 int res1 = 0 ;
31432 wxSize temp2 ;
31433 PyObject * obj0 = 0 ;
31434 PyObject * obj1 = 0 ;
31435 char * kwnames[] = {
31436 (char *) "self",(char *) "size", NULL
31437 };
31438
31439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31441 if (!SWIG_IsOK(res1)) {
31442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31443 }
31444 arg1 = reinterpret_cast< wxWindow * >(argp1);
31445 {
31446 arg2 = &temp2;
31447 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31448 }
31449 {
31450 PyThreadState* __tstate = wxPyBeginAllowThreads();
31451 (arg1)->SetSize((wxSize const &)*arg2);
31452 wxPyEndAllowThreads(__tstate);
31453 if (PyErr_Occurred()) SWIG_fail;
31454 }
31455 resultobj = SWIG_Py_Void();
31456 return resultobj;
31457 fail:
31458 return NULL;
31459 }
31460
31461
31462 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31463 PyObject *resultobj = 0;
31464 wxWindow *arg1 = (wxWindow *) 0 ;
31465 int arg2 ;
31466 int arg3 ;
31467 int arg4 ;
31468 int arg5 ;
31469 int arg6 = (int) wxSIZE_AUTO ;
31470 void *argp1 = 0 ;
31471 int res1 = 0 ;
31472 int val2 ;
31473 int ecode2 = 0 ;
31474 int val3 ;
31475 int ecode3 = 0 ;
31476 int val4 ;
31477 int ecode4 = 0 ;
31478 int val5 ;
31479 int ecode5 = 0 ;
31480 int val6 ;
31481 int ecode6 = 0 ;
31482 PyObject * obj0 = 0 ;
31483 PyObject * obj1 = 0 ;
31484 PyObject * obj2 = 0 ;
31485 PyObject * obj3 = 0 ;
31486 PyObject * obj4 = 0 ;
31487 PyObject * obj5 = 0 ;
31488 char * kwnames[] = {
31489 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31490 };
31491
31492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31494 if (!SWIG_IsOK(res1)) {
31495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31496 }
31497 arg1 = reinterpret_cast< wxWindow * >(argp1);
31498 ecode2 = SWIG_AsVal_int(obj1, &val2);
31499 if (!SWIG_IsOK(ecode2)) {
31500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31501 }
31502 arg2 = static_cast< int >(val2);
31503 ecode3 = SWIG_AsVal_int(obj2, &val3);
31504 if (!SWIG_IsOK(ecode3)) {
31505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31506 }
31507 arg3 = static_cast< int >(val3);
31508 ecode4 = SWIG_AsVal_int(obj3, &val4);
31509 if (!SWIG_IsOK(ecode4)) {
31510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31511 }
31512 arg4 = static_cast< int >(val4);
31513 ecode5 = SWIG_AsVal_int(obj4, &val5);
31514 if (!SWIG_IsOK(ecode5)) {
31515 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31516 }
31517 arg5 = static_cast< int >(val5);
31518 if (obj5) {
31519 ecode6 = SWIG_AsVal_int(obj5, &val6);
31520 if (!SWIG_IsOK(ecode6)) {
31521 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31522 }
31523 arg6 = static_cast< int >(val6);
31524 }
31525 {
31526 PyThreadState* __tstate = wxPyBeginAllowThreads();
31527 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31528 wxPyEndAllowThreads(__tstate);
31529 if (PyErr_Occurred()) SWIG_fail;
31530 }
31531 resultobj = SWIG_Py_Void();
31532 return resultobj;
31533 fail:
31534 return NULL;
31535 }
31536
31537
31538 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31539 PyObject *resultobj = 0;
31540 wxWindow *arg1 = (wxWindow *) 0 ;
31541 wxRect *arg2 = 0 ;
31542 int arg3 = (int) wxSIZE_AUTO ;
31543 void *argp1 = 0 ;
31544 int res1 = 0 ;
31545 wxRect temp2 ;
31546 int val3 ;
31547 int ecode3 = 0 ;
31548 PyObject * obj0 = 0 ;
31549 PyObject * obj1 = 0 ;
31550 PyObject * obj2 = 0 ;
31551 char * kwnames[] = {
31552 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31553 };
31554
31555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31557 if (!SWIG_IsOK(res1)) {
31558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31559 }
31560 arg1 = reinterpret_cast< wxWindow * >(argp1);
31561 {
31562 arg2 = &temp2;
31563 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31564 }
31565 if (obj2) {
31566 ecode3 = SWIG_AsVal_int(obj2, &val3);
31567 if (!SWIG_IsOK(ecode3)) {
31568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31569 }
31570 arg3 = static_cast< int >(val3);
31571 }
31572 {
31573 PyThreadState* __tstate = wxPyBeginAllowThreads();
31574 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31575 wxPyEndAllowThreads(__tstate);
31576 if (PyErr_Occurred()) SWIG_fail;
31577 }
31578 resultobj = SWIG_Py_Void();
31579 return resultobj;
31580 fail:
31581 return NULL;
31582 }
31583
31584
31585 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31586 PyObject *resultobj = 0;
31587 wxWindow *arg1 = (wxWindow *) 0 ;
31588 int arg2 ;
31589 int arg3 ;
31590 void *argp1 = 0 ;
31591 int res1 = 0 ;
31592 int val2 ;
31593 int ecode2 = 0 ;
31594 int val3 ;
31595 int ecode3 = 0 ;
31596 PyObject * obj0 = 0 ;
31597 PyObject * obj1 = 0 ;
31598 PyObject * obj2 = 0 ;
31599 char * kwnames[] = {
31600 (char *) "self",(char *) "width",(char *) "height", NULL
31601 };
31602
31603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31605 if (!SWIG_IsOK(res1)) {
31606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31607 }
31608 arg1 = reinterpret_cast< wxWindow * >(argp1);
31609 ecode2 = SWIG_AsVal_int(obj1, &val2);
31610 if (!SWIG_IsOK(ecode2)) {
31611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31612 }
31613 arg2 = static_cast< int >(val2);
31614 ecode3 = SWIG_AsVal_int(obj2, &val3);
31615 if (!SWIG_IsOK(ecode3)) {
31616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31617 }
31618 arg3 = static_cast< int >(val3);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 (arg1)->SetSize(arg2,arg3);
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_Py_Void();
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31633 PyObject *resultobj = 0;
31634 wxWindow *arg1 = (wxWindow *) 0 ;
31635 wxPoint *arg2 = 0 ;
31636 int arg3 = (int) wxSIZE_USE_EXISTING ;
31637 void *argp1 = 0 ;
31638 int res1 = 0 ;
31639 wxPoint temp2 ;
31640 int val3 ;
31641 int ecode3 = 0 ;
31642 PyObject * obj0 = 0 ;
31643 PyObject * obj1 = 0 ;
31644 PyObject * obj2 = 0 ;
31645 char * kwnames[] = {
31646 (char *) "self",(char *) "pt",(char *) "flags", NULL
31647 };
31648
31649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31651 if (!SWIG_IsOK(res1)) {
31652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31653 }
31654 arg1 = reinterpret_cast< wxWindow * >(argp1);
31655 {
31656 arg2 = &temp2;
31657 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31658 }
31659 if (obj2) {
31660 ecode3 = SWIG_AsVal_int(obj2, &val3);
31661 if (!SWIG_IsOK(ecode3)) {
31662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31663 }
31664 arg3 = static_cast< int >(val3);
31665 }
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 (arg1)->Move((wxPoint const &)*arg2,arg3);
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 resultobj = SWIG_Py_Void();
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj = 0;
31681 wxWindow *arg1 = (wxWindow *) 0 ;
31682 int arg2 ;
31683 int arg3 ;
31684 int arg4 = (int) wxSIZE_USE_EXISTING ;
31685 void *argp1 = 0 ;
31686 int res1 = 0 ;
31687 int val2 ;
31688 int ecode2 = 0 ;
31689 int val3 ;
31690 int ecode3 = 0 ;
31691 int val4 ;
31692 int ecode4 = 0 ;
31693 PyObject * obj0 = 0 ;
31694 PyObject * obj1 = 0 ;
31695 PyObject * obj2 = 0 ;
31696 PyObject * obj3 = 0 ;
31697 char * kwnames[] = {
31698 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31699 };
31700
31701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31705 }
31706 arg1 = reinterpret_cast< wxWindow * >(argp1);
31707 ecode2 = SWIG_AsVal_int(obj1, &val2);
31708 if (!SWIG_IsOK(ecode2)) {
31709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31710 }
31711 arg2 = static_cast< int >(val2);
31712 ecode3 = SWIG_AsVal_int(obj2, &val3);
31713 if (!SWIG_IsOK(ecode3)) {
31714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31715 }
31716 arg3 = static_cast< int >(val3);
31717 if (obj3) {
31718 ecode4 = SWIG_AsVal_int(obj3, &val4);
31719 if (!SWIG_IsOK(ecode4)) {
31720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31721 }
31722 arg4 = static_cast< int >(val4);
31723 }
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 (arg1)->Move(arg2,arg3,arg4);
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 resultobj = SWIG_Py_Void();
31731 return resultobj;
31732 fail:
31733 return NULL;
31734 }
31735
31736
31737 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31738 PyObject *resultobj = 0;
31739 wxWindow *arg1 = (wxWindow *) 0 ;
31740 wxSize const &arg2_defvalue = wxDefaultSize ;
31741 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31742 void *argp1 = 0 ;
31743 int res1 = 0 ;
31744 wxSize temp2 ;
31745 PyObject * obj0 = 0 ;
31746 PyObject * obj1 = 0 ;
31747 char * kwnames[] = {
31748 (char *) "self",(char *) "size", NULL
31749 };
31750
31751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31753 if (!SWIG_IsOK(res1)) {
31754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31755 }
31756 arg1 = reinterpret_cast< wxWindow * >(argp1);
31757 if (obj1) {
31758 {
31759 arg2 = &temp2;
31760 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31761 }
31762 }
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 resultobj = SWIG_Py_Void();
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31777 PyObject *resultobj = 0;
31778 wxWindow *arg1 = (wxWindow *) 0 ;
31779 void *argp1 = 0 ;
31780 int res1 = 0 ;
31781 PyObject *swig_obj[1] ;
31782
31783 if (!args) SWIG_fail;
31784 swig_obj[0] = args;
31785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31786 if (!SWIG_IsOK(res1)) {
31787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31788 }
31789 arg1 = reinterpret_cast< wxWindow * >(argp1);
31790 {
31791 PyThreadState* __tstate = wxPyBeginAllowThreads();
31792 (arg1)->Raise();
31793 wxPyEndAllowThreads(__tstate);
31794 if (PyErr_Occurred()) SWIG_fail;
31795 }
31796 resultobj = SWIG_Py_Void();
31797 return resultobj;
31798 fail:
31799 return NULL;
31800 }
31801
31802
31803 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31804 PyObject *resultobj = 0;
31805 wxWindow *arg1 = (wxWindow *) 0 ;
31806 void *argp1 = 0 ;
31807 int res1 = 0 ;
31808 PyObject *swig_obj[1] ;
31809
31810 if (!args) SWIG_fail;
31811 swig_obj[0] = args;
31812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31813 if (!SWIG_IsOK(res1)) {
31814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31815 }
31816 arg1 = reinterpret_cast< wxWindow * >(argp1);
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 (arg1)->Lower();
31820 wxPyEndAllowThreads(__tstate);
31821 if (PyErr_Occurred()) SWIG_fail;
31822 }
31823 resultobj = SWIG_Py_Void();
31824 return resultobj;
31825 fail:
31826 return NULL;
31827 }
31828
31829
31830 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31831 PyObject *resultobj = 0;
31832 wxWindow *arg1 = (wxWindow *) 0 ;
31833 wxSize *arg2 = 0 ;
31834 void *argp1 = 0 ;
31835 int res1 = 0 ;
31836 wxSize temp2 ;
31837 PyObject * obj0 = 0 ;
31838 PyObject * obj1 = 0 ;
31839 char * kwnames[] = {
31840 (char *) "self",(char *) "size", NULL
31841 };
31842
31843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) 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_SetClientSize" "', 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 {
31854 PyThreadState* __tstate = wxPyBeginAllowThreads();
31855 (arg1)->SetClientSize((wxSize const &)*arg2);
31856 wxPyEndAllowThreads(__tstate);
31857 if (PyErr_Occurred()) SWIG_fail;
31858 }
31859 resultobj = SWIG_Py_Void();
31860 return resultobj;
31861 fail:
31862 return NULL;
31863 }
31864
31865
31866 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31867 PyObject *resultobj = 0;
31868 wxWindow *arg1 = (wxWindow *) 0 ;
31869 int arg2 ;
31870 int arg3 ;
31871 void *argp1 = 0 ;
31872 int res1 = 0 ;
31873 int val2 ;
31874 int ecode2 = 0 ;
31875 int val3 ;
31876 int ecode3 = 0 ;
31877 PyObject * obj0 = 0 ;
31878 PyObject * obj1 = 0 ;
31879 PyObject * obj2 = 0 ;
31880 char * kwnames[] = {
31881 (char *) "self",(char *) "width",(char *) "height", NULL
31882 };
31883
31884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31886 if (!SWIG_IsOK(res1)) {
31887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31888 }
31889 arg1 = reinterpret_cast< wxWindow * >(argp1);
31890 ecode2 = SWIG_AsVal_int(obj1, &val2);
31891 if (!SWIG_IsOK(ecode2)) {
31892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31893 }
31894 arg2 = static_cast< int >(val2);
31895 ecode3 = SWIG_AsVal_int(obj2, &val3);
31896 if (!SWIG_IsOK(ecode3)) {
31897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31898 }
31899 arg3 = static_cast< int >(val3);
31900 {
31901 PyThreadState* __tstate = wxPyBeginAllowThreads();
31902 (arg1)->SetClientSize(arg2,arg3);
31903 wxPyEndAllowThreads(__tstate);
31904 if (PyErr_Occurred()) SWIG_fail;
31905 }
31906 resultobj = SWIG_Py_Void();
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31914 PyObject *resultobj = 0;
31915 wxWindow *arg1 = (wxWindow *) 0 ;
31916 wxRect *arg2 = 0 ;
31917 void *argp1 = 0 ;
31918 int res1 = 0 ;
31919 wxRect temp2 ;
31920 PyObject * obj0 = 0 ;
31921 PyObject * obj1 = 0 ;
31922 char * kwnames[] = {
31923 (char *) "self",(char *) "rect", NULL
31924 };
31925
31926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31928 if (!SWIG_IsOK(res1)) {
31929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31930 }
31931 arg1 = reinterpret_cast< wxWindow * >(argp1);
31932 {
31933 arg2 = &temp2;
31934 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31935 }
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 (arg1)->SetClientSize((wxRect const &)*arg2);
31939 wxPyEndAllowThreads(__tstate);
31940 if (PyErr_Occurred()) SWIG_fail;
31941 }
31942 resultobj = SWIG_Py_Void();
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31950 PyObject *resultobj = 0;
31951 wxWindow *arg1 = (wxWindow *) 0 ;
31952 wxPoint result;
31953 void *argp1 = 0 ;
31954 int res1 = 0 ;
31955 PyObject *swig_obj[1] ;
31956
31957 if (!args) SWIG_fail;
31958 swig_obj[0] = args;
31959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31962 }
31963 arg1 = reinterpret_cast< wxWindow * >(argp1);
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 result = ((wxWindow const *)arg1)->GetPosition();
31967 wxPyEndAllowThreads(__tstate);
31968 if (PyErr_Occurred()) SWIG_fail;
31969 }
31970 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31971 return resultobj;
31972 fail:
31973 return NULL;
31974 }
31975
31976
31977 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31978 PyObject *resultobj = 0;
31979 wxWindow *arg1 = (wxWindow *) 0 ;
31980 int *arg2 = (int *) 0 ;
31981 int *arg3 = (int *) 0 ;
31982 void *argp1 = 0 ;
31983 int res1 = 0 ;
31984 int temp2 ;
31985 int res2 = SWIG_TMPOBJ ;
31986 int temp3 ;
31987 int res3 = SWIG_TMPOBJ ;
31988 PyObject *swig_obj[1] ;
31989
31990 arg2 = &temp2;
31991 arg3 = &temp3;
31992 if (!args) SWIG_fail;
31993 swig_obj[0] = args;
31994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31995 if (!SWIG_IsOK(res1)) {
31996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31997 }
31998 arg1 = reinterpret_cast< wxWindow * >(argp1);
31999 {
32000 PyThreadState* __tstate = wxPyBeginAllowThreads();
32001 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
32002 wxPyEndAllowThreads(__tstate);
32003 if (PyErr_Occurred()) SWIG_fail;
32004 }
32005 resultobj = SWIG_Py_Void();
32006 if (SWIG_IsTmpObj(res2)) {
32007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32008 } else {
32009 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32011 }
32012 if (SWIG_IsTmpObj(res3)) {
32013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32014 } else {
32015 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32017 }
32018 return resultobj;
32019 fail:
32020 return NULL;
32021 }
32022
32023
32024 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32025 PyObject *resultobj = 0;
32026 wxWindow *arg1 = (wxWindow *) 0 ;
32027 wxPoint result;
32028 void *argp1 = 0 ;
32029 int res1 = 0 ;
32030 PyObject *swig_obj[1] ;
32031
32032 if (!args) SWIG_fail;
32033 swig_obj[0] = args;
32034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32035 if (!SWIG_IsOK(res1)) {
32036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32037 }
32038 arg1 = reinterpret_cast< wxWindow * >(argp1);
32039 {
32040 PyThreadState* __tstate = wxPyBeginAllowThreads();
32041 result = ((wxWindow const *)arg1)->GetScreenPosition();
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32046 return resultobj;
32047 fail:
32048 return NULL;
32049 }
32050
32051
32052 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32053 PyObject *resultobj = 0;
32054 wxWindow *arg1 = (wxWindow *) 0 ;
32055 int *arg2 = (int *) 0 ;
32056 int *arg3 = (int *) 0 ;
32057 void *argp1 = 0 ;
32058 int res1 = 0 ;
32059 int temp2 ;
32060 int res2 = SWIG_TMPOBJ ;
32061 int temp3 ;
32062 int res3 = SWIG_TMPOBJ ;
32063 PyObject *swig_obj[1] ;
32064
32065 arg2 = &temp2;
32066 arg3 = &temp3;
32067 if (!args) SWIG_fail;
32068 swig_obj[0] = args;
32069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32070 if (!SWIG_IsOK(res1)) {
32071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32072 }
32073 arg1 = reinterpret_cast< wxWindow * >(argp1);
32074 {
32075 PyThreadState* __tstate = wxPyBeginAllowThreads();
32076 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32077 wxPyEndAllowThreads(__tstate);
32078 if (PyErr_Occurred()) SWIG_fail;
32079 }
32080 resultobj = SWIG_Py_Void();
32081 if (SWIG_IsTmpObj(res2)) {
32082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32083 } else {
32084 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32086 }
32087 if (SWIG_IsTmpObj(res3)) {
32088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32089 } else {
32090 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32092 }
32093 return resultobj;
32094 fail:
32095 return NULL;
32096 }
32097
32098
32099 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32100 PyObject *resultobj = 0;
32101 wxWindow *arg1 = (wxWindow *) 0 ;
32102 wxRect result;
32103 void *argp1 = 0 ;
32104 int res1 = 0 ;
32105 PyObject *swig_obj[1] ;
32106
32107 if (!args) SWIG_fail;
32108 swig_obj[0] = args;
32109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32110 if (!SWIG_IsOK(res1)) {
32111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32112 }
32113 arg1 = reinterpret_cast< wxWindow * >(argp1);
32114 {
32115 PyThreadState* __tstate = wxPyBeginAllowThreads();
32116 result = ((wxWindow const *)arg1)->GetScreenRect();
32117 wxPyEndAllowThreads(__tstate);
32118 if (PyErr_Occurred()) SWIG_fail;
32119 }
32120 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32128 PyObject *resultobj = 0;
32129 wxWindow *arg1 = (wxWindow *) 0 ;
32130 wxSize result;
32131 void *argp1 = 0 ;
32132 int res1 = 0 ;
32133 PyObject *swig_obj[1] ;
32134
32135 if (!args) SWIG_fail;
32136 swig_obj[0] = args;
32137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32138 if (!SWIG_IsOK(res1)) {
32139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32140 }
32141 arg1 = reinterpret_cast< wxWindow * >(argp1);
32142 {
32143 PyThreadState* __tstate = wxPyBeginAllowThreads();
32144 result = ((wxWindow const *)arg1)->GetSize();
32145 wxPyEndAllowThreads(__tstate);
32146 if (PyErr_Occurred()) SWIG_fail;
32147 }
32148 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32149 return resultobj;
32150 fail:
32151 return NULL;
32152 }
32153
32154
32155 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32156 PyObject *resultobj = 0;
32157 wxWindow *arg1 = (wxWindow *) 0 ;
32158 int *arg2 = (int *) 0 ;
32159 int *arg3 = (int *) 0 ;
32160 void *argp1 = 0 ;
32161 int res1 = 0 ;
32162 int temp2 ;
32163 int res2 = SWIG_TMPOBJ ;
32164 int temp3 ;
32165 int res3 = SWIG_TMPOBJ ;
32166 PyObject *swig_obj[1] ;
32167
32168 arg2 = &temp2;
32169 arg3 = &temp3;
32170 if (!args) SWIG_fail;
32171 swig_obj[0] = args;
32172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32173 if (!SWIG_IsOK(res1)) {
32174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32175 }
32176 arg1 = reinterpret_cast< wxWindow * >(argp1);
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 resultobj = SWIG_Py_Void();
32184 if (SWIG_IsTmpObj(res2)) {
32185 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32186 } else {
32187 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32188 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32189 }
32190 if (SWIG_IsTmpObj(res3)) {
32191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32192 } else {
32193 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32195 }
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32203 PyObject *resultobj = 0;
32204 wxWindow *arg1 = (wxWindow *) 0 ;
32205 wxRect result;
32206 void *argp1 = 0 ;
32207 int res1 = 0 ;
32208 PyObject *swig_obj[1] ;
32209
32210 if (!args) SWIG_fail;
32211 swig_obj[0] = args;
32212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32213 if (!SWIG_IsOK(res1)) {
32214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32215 }
32216 arg1 = reinterpret_cast< wxWindow * >(argp1);
32217 {
32218 PyThreadState* __tstate = wxPyBeginAllowThreads();
32219 result = ((wxWindow const *)arg1)->GetRect();
32220 wxPyEndAllowThreads(__tstate);
32221 if (PyErr_Occurred()) SWIG_fail;
32222 }
32223 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32231 PyObject *resultobj = 0;
32232 wxWindow *arg1 = (wxWindow *) 0 ;
32233 wxSize result;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 PyObject *swig_obj[1] ;
32237
32238 if (!args) SWIG_fail;
32239 swig_obj[0] = args;
32240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32243 }
32244 arg1 = reinterpret_cast< wxWindow * >(argp1);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = ((wxWindow const *)arg1)->GetClientSize();
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32259 PyObject *resultobj = 0;
32260 wxWindow *arg1 = (wxWindow *) 0 ;
32261 int *arg2 = (int *) 0 ;
32262 int *arg3 = (int *) 0 ;
32263 void *argp1 = 0 ;
32264 int res1 = 0 ;
32265 int temp2 ;
32266 int res2 = SWIG_TMPOBJ ;
32267 int temp3 ;
32268 int res3 = SWIG_TMPOBJ ;
32269 PyObject *swig_obj[1] ;
32270
32271 arg2 = &temp2;
32272 arg3 = &temp3;
32273 if (!args) SWIG_fail;
32274 swig_obj[0] = args;
32275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32276 if (!SWIG_IsOK(res1)) {
32277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32278 }
32279 arg1 = reinterpret_cast< wxWindow * >(argp1);
32280 {
32281 PyThreadState* __tstate = wxPyBeginAllowThreads();
32282 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32283 wxPyEndAllowThreads(__tstate);
32284 if (PyErr_Occurred()) SWIG_fail;
32285 }
32286 resultobj = SWIG_Py_Void();
32287 if (SWIG_IsTmpObj(res2)) {
32288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32289 } else {
32290 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32292 }
32293 if (SWIG_IsTmpObj(res3)) {
32294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32295 } else {
32296 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32298 }
32299 return resultobj;
32300 fail:
32301 return NULL;
32302 }
32303
32304
32305 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32306 PyObject *resultobj = 0;
32307 wxWindow *arg1 = (wxWindow *) 0 ;
32308 wxPoint result;
32309 void *argp1 = 0 ;
32310 int res1 = 0 ;
32311 PyObject *swig_obj[1] ;
32312
32313 if (!args) SWIG_fail;
32314 swig_obj[0] = args;
32315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32316 if (!SWIG_IsOK(res1)) {
32317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32318 }
32319 arg1 = reinterpret_cast< wxWindow * >(argp1);
32320 {
32321 PyThreadState* __tstate = wxPyBeginAllowThreads();
32322 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32323 wxPyEndAllowThreads(__tstate);
32324 if (PyErr_Occurred()) SWIG_fail;
32325 }
32326 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32327 return resultobj;
32328 fail:
32329 return NULL;
32330 }
32331
32332
32333 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32334 PyObject *resultobj = 0;
32335 wxWindow *arg1 = (wxWindow *) 0 ;
32336 wxRect result;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 PyObject *swig_obj[1] ;
32340
32341 if (!args) SWIG_fail;
32342 swig_obj[0] = args;
32343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32344 if (!SWIG_IsOK(res1)) {
32345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32346 }
32347 arg1 = reinterpret_cast< wxWindow * >(argp1);
32348 {
32349 PyThreadState* __tstate = wxPyBeginAllowThreads();
32350 result = ((wxWindow const *)arg1)->GetClientRect();
32351 wxPyEndAllowThreads(__tstate);
32352 if (PyErr_Occurred()) SWIG_fail;
32353 }
32354 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32355 return resultobj;
32356 fail:
32357 return NULL;
32358 }
32359
32360
32361 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32362 PyObject *resultobj = 0;
32363 wxWindow *arg1 = (wxWindow *) 0 ;
32364 wxSize result;
32365 void *argp1 = 0 ;
32366 int res1 = 0 ;
32367 PyObject *swig_obj[1] ;
32368
32369 if (!args) SWIG_fail;
32370 swig_obj[0] = args;
32371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32372 if (!SWIG_IsOK(res1)) {
32373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32374 }
32375 arg1 = reinterpret_cast< wxWindow * >(argp1);
32376 {
32377 PyThreadState* __tstate = wxPyBeginAllowThreads();
32378 result = ((wxWindow const *)arg1)->GetBestSize();
32379 wxPyEndAllowThreads(__tstate);
32380 if (PyErr_Occurred()) SWIG_fail;
32381 }
32382 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32383 return resultobj;
32384 fail:
32385 return NULL;
32386 }
32387
32388
32389 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32390 PyObject *resultobj = 0;
32391 wxWindow *arg1 = (wxWindow *) 0 ;
32392 int *arg2 = (int *) 0 ;
32393 int *arg3 = (int *) 0 ;
32394 void *argp1 = 0 ;
32395 int res1 = 0 ;
32396 int temp2 ;
32397 int res2 = SWIG_TMPOBJ ;
32398 int temp3 ;
32399 int res3 = SWIG_TMPOBJ ;
32400 PyObject *swig_obj[1] ;
32401
32402 arg2 = &temp2;
32403 arg3 = &temp3;
32404 if (!args) SWIG_fail;
32405 swig_obj[0] = args;
32406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32407 if (!SWIG_IsOK(res1)) {
32408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32409 }
32410 arg1 = reinterpret_cast< wxWindow * >(argp1);
32411 {
32412 PyThreadState* __tstate = wxPyBeginAllowThreads();
32413 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32414 wxPyEndAllowThreads(__tstate);
32415 if (PyErr_Occurred()) SWIG_fail;
32416 }
32417 resultobj = SWIG_Py_Void();
32418 if (SWIG_IsTmpObj(res2)) {
32419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32420 } else {
32421 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32422 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32423 }
32424 if (SWIG_IsTmpObj(res3)) {
32425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32426 } else {
32427 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32429 }
32430 return resultobj;
32431 fail:
32432 return NULL;
32433 }
32434
32435
32436 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32437 PyObject *resultobj = 0;
32438 wxWindow *arg1 = (wxWindow *) 0 ;
32439 void *argp1 = 0 ;
32440 int res1 = 0 ;
32441 PyObject *swig_obj[1] ;
32442
32443 if (!args) SWIG_fail;
32444 swig_obj[0] = args;
32445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32446 if (!SWIG_IsOK(res1)) {
32447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32448 }
32449 arg1 = reinterpret_cast< wxWindow * >(argp1);
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 (arg1)->InvalidateBestSize();
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 resultobj = SWIG_Py_Void();
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32464 PyObject *resultobj = 0;
32465 wxWindow *arg1 = (wxWindow *) 0 ;
32466 wxSize *arg2 = 0 ;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 wxSize temp2 ;
32470 PyObject * obj0 = 0 ;
32471 PyObject * obj1 = 0 ;
32472 char * kwnames[] = {
32473 (char *) "self",(char *) "size", NULL
32474 };
32475
32476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32478 if (!SWIG_IsOK(res1)) {
32479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32480 }
32481 arg1 = reinterpret_cast< wxWindow * >(argp1);
32482 {
32483 arg2 = &temp2;
32484 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32485 }
32486 {
32487 PyThreadState* __tstate = wxPyBeginAllowThreads();
32488 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32489 wxPyEndAllowThreads(__tstate);
32490 if (PyErr_Occurred()) SWIG_fail;
32491 }
32492 resultobj = SWIG_Py_Void();
32493 return resultobj;
32494 fail:
32495 return NULL;
32496 }
32497
32498
32499 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32500 PyObject *resultobj = 0;
32501 wxWindow *arg1 = (wxWindow *) 0 ;
32502 wxSize result;
32503 void *argp1 = 0 ;
32504 int res1 = 0 ;
32505 PyObject *swig_obj[1] ;
32506
32507 if (!args) SWIG_fail;
32508 swig_obj[0] = args;
32509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32510 if (!SWIG_IsOK(res1)) {
32511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32512 }
32513 arg1 = reinterpret_cast< wxWindow * >(argp1);
32514 {
32515 PyThreadState* __tstate = wxPyBeginAllowThreads();
32516 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32517 wxPyEndAllowThreads(__tstate);
32518 if (PyErr_Occurred()) SWIG_fail;
32519 }
32520 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32521 return resultobj;
32522 fail:
32523 return NULL;
32524 }
32525
32526
32527 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32528 PyObject *resultobj = 0;
32529 wxWindow *arg1 = (wxWindow *) 0 ;
32530 wxSize result;
32531 void *argp1 = 0 ;
32532 int res1 = 0 ;
32533 PyObject *swig_obj[1] ;
32534
32535 if (!args) SWIG_fail;
32536 swig_obj[0] = args;
32537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32538 if (!SWIG_IsOK(res1)) {
32539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32540 }
32541 arg1 = reinterpret_cast< wxWindow * >(argp1);
32542 {
32543 PyThreadState* __tstate = wxPyBeginAllowThreads();
32544 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32545 wxPyEndAllowThreads(__tstate);
32546 if (PyErr_Occurred()) SWIG_fail;
32547 }
32548 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32549 return resultobj;
32550 fail:
32551 return NULL;
32552 }
32553
32554
32555 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32556 PyObject *resultobj = 0;
32557 wxWindow *arg1 = (wxWindow *) 0 ;
32558 int arg2 = (int) wxBOTH ;
32559 void *argp1 = 0 ;
32560 int res1 = 0 ;
32561 int val2 ;
32562 int ecode2 = 0 ;
32563 PyObject * obj0 = 0 ;
32564 PyObject * obj1 = 0 ;
32565 char * kwnames[] = {
32566 (char *) "self",(char *) "direction", NULL
32567 };
32568
32569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32571 if (!SWIG_IsOK(res1)) {
32572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32573 }
32574 arg1 = reinterpret_cast< wxWindow * >(argp1);
32575 if (obj1) {
32576 ecode2 = SWIG_AsVal_int(obj1, &val2);
32577 if (!SWIG_IsOK(ecode2)) {
32578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32579 }
32580 arg2 = static_cast< int >(val2);
32581 }
32582 {
32583 PyThreadState* __tstate = wxPyBeginAllowThreads();
32584 (arg1)->Center(arg2);
32585 wxPyEndAllowThreads(__tstate);
32586 if (PyErr_Occurred()) SWIG_fail;
32587 }
32588 resultobj = SWIG_Py_Void();
32589 return resultobj;
32590 fail:
32591 return NULL;
32592 }
32593
32594
32595 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32596 PyObject *resultobj = 0;
32597 wxWindow *arg1 = (wxWindow *) 0 ;
32598 int arg2 = (int) wxBOTH ;
32599 void *argp1 = 0 ;
32600 int res1 = 0 ;
32601 int val2 ;
32602 int ecode2 = 0 ;
32603 PyObject * obj0 = 0 ;
32604 PyObject * obj1 = 0 ;
32605 char * kwnames[] = {
32606 (char *) "self",(char *) "dir", NULL
32607 };
32608
32609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32611 if (!SWIG_IsOK(res1)) {
32612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32613 }
32614 arg1 = reinterpret_cast< wxWindow * >(argp1);
32615 if (obj1) {
32616 ecode2 = SWIG_AsVal_int(obj1, &val2);
32617 if (!SWIG_IsOK(ecode2)) {
32618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32619 }
32620 arg2 = static_cast< int >(val2);
32621 }
32622 {
32623 PyThreadState* __tstate = wxPyBeginAllowThreads();
32624 (arg1)->CenterOnParent(arg2);
32625 wxPyEndAllowThreads(__tstate);
32626 if (PyErr_Occurred()) SWIG_fail;
32627 }
32628 resultobj = SWIG_Py_Void();
32629 return resultobj;
32630 fail:
32631 return NULL;
32632 }
32633
32634
32635 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32636 PyObject *resultobj = 0;
32637 wxWindow *arg1 = (wxWindow *) 0 ;
32638 void *argp1 = 0 ;
32639 int res1 = 0 ;
32640 PyObject *swig_obj[1] ;
32641
32642 if (!args) SWIG_fail;
32643 swig_obj[0] = args;
32644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32645 if (!SWIG_IsOK(res1)) {
32646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32647 }
32648 arg1 = reinterpret_cast< wxWindow * >(argp1);
32649 {
32650 PyThreadState* __tstate = wxPyBeginAllowThreads();
32651 (arg1)->Fit();
32652 wxPyEndAllowThreads(__tstate);
32653 if (PyErr_Occurred()) SWIG_fail;
32654 }
32655 resultobj = SWIG_Py_Void();
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32663 PyObject *resultobj = 0;
32664 wxWindow *arg1 = (wxWindow *) 0 ;
32665 void *argp1 = 0 ;
32666 int res1 = 0 ;
32667 PyObject *swig_obj[1] ;
32668
32669 if (!args) SWIG_fail;
32670 swig_obj[0] = args;
32671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32672 if (!SWIG_IsOK(res1)) {
32673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32674 }
32675 arg1 = reinterpret_cast< wxWindow * >(argp1);
32676 {
32677 PyThreadState* __tstate = wxPyBeginAllowThreads();
32678 (arg1)->FitInside();
32679 wxPyEndAllowThreads(__tstate);
32680 if (PyErr_Occurred()) SWIG_fail;
32681 }
32682 resultobj = SWIG_Py_Void();
32683 return resultobj;
32684 fail:
32685 return NULL;
32686 }
32687
32688
32689 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32690 PyObject *resultobj = 0;
32691 wxWindow *arg1 = (wxWindow *) 0 ;
32692 int arg2 ;
32693 int arg3 ;
32694 int arg4 = (int) -1 ;
32695 int arg5 = (int) -1 ;
32696 int arg6 = (int) -1 ;
32697 int arg7 = (int) -1 ;
32698 void *argp1 = 0 ;
32699 int res1 = 0 ;
32700 int val2 ;
32701 int ecode2 = 0 ;
32702 int val3 ;
32703 int ecode3 = 0 ;
32704 int val4 ;
32705 int ecode4 = 0 ;
32706 int val5 ;
32707 int ecode5 = 0 ;
32708 int val6 ;
32709 int ecode6 = 0 ;
32710 int val7 ;
32711 int ecode7 = 0 ;
32712 PyObject * obj0 = 0 ;
32713 PyObject * obj1 = 0 ;
32714 PyObject * obj2 = 0 ;
32715 PyObject * obj3 = 0 ;
32716 PyObject * obj4 = 0 ;
32717 PyObject * obj5 = 0 ;
32718 PyObject * obj6 = 0 ;
32719 char * kwnames[] = {
32720 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32721 };
32722
32723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32725 if (!SWIG_IsOK(res1)) {
32726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32727 }
32728 arg1 = reinterpret_cast< wxWindow * >(argp1);
32729 ecode2 = SWIG_AsVal_int(obj1, &val2);
32730 if (!SWIG_IsOK(ecode2)) {
32731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32732 }
32733 arg2 = static_cast< int >(val2);
32734 ecode3 = SWIG_AsVal_int(obj2, &val3);
32735 if (!SWIG_IsOK(ecode3)) {
32736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32737 }
32738 arg3 = static_cast< int >(val3);
32739 if (obj3) {
32740 ecode4 = SWIG_AsVal_int(obj3, &val4);
32741 if (!SWIG_IsOK(ecode4)) {
32742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32743 }
32744 arg4 = static_cast< int >(val4);
32745 }
32746 if (obj4) {
32747 ecode5 = SWIG_AsVal_int(obj4, &val5);
32748 if (!SWIG_IsOK(ecode5)) {
32749 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32750 }
32751 arg5 = static_cast< int >(val5);
32752 }
32753 if (obj5) {
32754 ecode6 = SWIG_AsVal_int(obj5, &val6);
32755 if (!SWIG_IsOK(ecode6)) {
32756 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32757 }
32758 arg6 = static_cast< int >(val6);
32759 }
32760 if (obj6) {
32761 ecode7 = SWIG_AsVal_int(obj6, &val7);
32762 if (!SWIG_IsOK(ecode7)) {
32763 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32764 }
32765 arg7 = static_cast< int >(val7);
32766 }
32767 {
32768 PyThreadState* __tstate = wxPyBeginAllowThreads();
32769 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32770 wxPyEndAllowThreads(__tstate);
32771 if (PyErr_Occurred()) SWIG_fail;
32772 }
32773 resultobj = SWIG_Py_Void();
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32781 PyObject *resultobj = 0;
32782 wxWindow *arg1 = (wxWindow *) 0 ;
32783 wxSize *arg2 = 0 ;
32784 wxSize const &arg3_defvalue = wxDefaultSize ;
32785 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32786 wxSize const &arg4_defvalue = wxDefaultSize ;
32787 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32788 void *argp1 = 0 ;
32789 int res1 = 0 ;
32790 wxSize temp2 ;
32791 wxSize temp3 ;
32792 wxSize temp4 ;
32793 PyObject * obj0 = 0 ;
32794 PyObject * obj1 = 0 ;
32795 PyObject * obj2 = 0 ;
32796 PyObject * obj3 = 0 ;
32797 char * kwnames[] = {
32798 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32799 };
32800
32801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32803 if (!SWIG_IsOK(res1)) {
32804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32805 }
32806 arg1 = reinterpret_cast< wxWindow * >(argp1);
32807 {
32808 arg2 = &temp2;
32809 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32810 }
32811 if (obj2) {
32812 {
32813 arg3 = &temp3;
32814 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32815 }
32816 }
32817 if (obj3) {
32818 {
32819 arg4 = &temp4;
32820 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32821 }
32822 }
32823 {
32824 PyThreadState* __tstate = wxPyBeginAllowThreads();
32825 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32826 wxPyEndAllowThreads(__tstate);
32827 if (PyErr_Occurred()) SWIG_fail;
32828 }
32829 resultobj = SWIG_Py_Void();
32830 return resultobj;
32831 fail:
32832 return NULL;
32833 }
32834
32835
32836 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32837 PyObject *resultobj = 0;
32838 wxWindow *arg1 = (wxWindow *) 0 ;
32839 int arg2 ;
32840 int arg3 ;
32841 int arg4 = (int) -1 ;
32842 int arg5 = (int) -1 ;
32843 void *argp1 = 0 ;
32844 int res1 = 0 ;
32845 int val2 ;
32846 int ecode2 = 0 ;
32847 int val3 ;
32848 int ecode3 = 0 ;
32849 int val4 ;
32850 int ecode4 = 0 ;
32851 int val5 ;
32852 int ecode5 = 0 ;
32853 PyObject * obj0 = 0 ;
32854 PyObject * obj1 = 0 ;
32855 PyObject * obj2 = 0 ;
32856 PyObject * obj3 = 0 ;
32857 PyObject * obj4 = 0 ;
32858 char * kwnames[] = {
32859 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32860 };
32861
32862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32864 if (!SWIG_IsOK(res1)) {
32865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32866 }
32867 arg1 = reinterpret_cast< wxWindow * >(argp1);
32868 ecode2 = SWIG_AsVal_int(obj1, &val2);
32869 if (!SWIG_IsOK(ecode2)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32871 }
32872 arg2 = static_cast< int >(val2);
32873 ecode3 = SWIG_AsVal_int(obj2, &val3);
32874 if (!SWIG_IsOK(ecode3)) {
32875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32876 }
32877 arg3 = static_cast< int >(val3);
32878 if (obj3) {
32879 ecode4 = SWIG_AsVal_int(obj3, &val4);
32880 if (!SWIG_IsOK(ecode4)) {
32881 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32882 }
32883 arg4 = static_cast< int >(val4);
32884 }
32885 if (obj4) {
32886 ecode5 = SWIG_AsVal_int(obj4, &val5);
32887 if (!SWIG_IsOK(ecode5)) {
32888 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32889 }
32890 arg5 = static_cast< int >(val5);
32891 }
32892 {
32893 PyThreadState* __tstate = wxPyBeginAllowThreads();
32894 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32895 wxPyEndAllowThreads(__tstate);
32896 if (PyErr_Occurred()) SWIG_fail;
32897 }
32898 resultobj = SWIG_Py_Void();
32899 return resultobj;
32900 fail:
32901 return NULL;
32902 }
32903
32904
32905 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32906 PyObject *resultobj = 0;
32907 wxWindow *arg1 = (wxWindow *) 0 ;
32908 wxSize *arg2 = 0 ;
32909 wxSize const &arg3_defvalue = wxDefaultSize ;
32910 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32911 void *argp1 = 0 ;
32912 int res1 = 0 ;
32913 wxSize temp2 ;
32914 wxSize temp3 ;
32915 PyObject * obj0 = 0 ;
32916 PyObject * obj1 = 0 ;
32917 PyObject * obj2 = 0 ;
32918 char * kwnames[] = {
32919 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32920 };
32921
32922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32924 if (!SWIG_IsOK(res1)) {
32925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32926 }
32927 arg1 = reinterpret_cast< wxWindow * >(argp1);
32928 {
32929 arg2 = &temp2;
32930 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32931 }
32932 if (obj2) {
32933 {
32934 arg3 = &temp3;
32935 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32936 }
32937 }
32938 {
32939 PyThreadState* __tstate = wxPyBeginAllowThreads();
32940 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32941 wxPyEndAllowThreads(__tstate);
32942 if (PyErr_Occurred()) SWIG_fail;
32943 }
32944 resultobj = SWIG_Py_Void();
32945 return resultobj;
32946 fail:
32947 return NULL;
32948 }
32949
32950
32951 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32952 PyObject *resultobj = 0;
32953 wxWindow *arg1 = (wxWindow *) 0 ;
32954 wxSize result;
32955 void *argp1 = 0 ;
32956 int res1 = 0 ;
32957 PyObject *swig_obj[1] ;
32958
32959 if (!args) SWIG_fail;
32960 swig_obj[0] = args;
32961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32962 if (!SWIG_IsOK(res1)) {
32963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32964 }
32965 arg1 = reinterpret_cast< wxWindow * >(argp1);
32966 {
32967 PyThreadState* __tstate = wxPyBeginAllowThreads();
32968 result = ((wxWindow const *)arg1)->GetMaxSize();
32969 wxPyEndAllowThreads(__tstate);
32970 if (PyErr_Occurred()) SWIG_fail;
32971 }
32972 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32973 return resultobj;
32974 fail:
32975 return NULL;
32976 }
32977
32978
32979 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32980 PyObject *resultobj = 0;
32981 wxWindow *arg1 = (wxWindow *) 0 ;
32982 wxSize result;
32983 void *argp1 = 0 ;
32984 int res1 = 0 ;
32985 PyObject *swig_obj[1] ;
32986
32987 if (!args) SWIG_fail;
32988 swig_obj[0] = args;
32989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32990 if (!SWIG_IsOK(res1)) {
32991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32992 }
32993 arg1 = reinterpret_cast< wxWindow * >(argp1);
32994 {
32995 PyThreadState* __tstate = wxPyBeginAllowThreads();
32996 result = ((wxWindow const *)arg1)->GetMinSize();
32997 wxPyEndAllowThreads(__tstate);
32998 if (PyErr_Occurred()) SWIG_fail;
32999 }
33000 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33001 return resultobj;
33002 fail:
33003 return NULL;
33004 }
33005
33006
33007 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33008 PyObject *resultobj = 0;
33009 wxWindow *arg1 = (wxWindow *) 0 ;
33010 wxSize *arg2 = 0 ;
33011 void *argp1 = 0 ;
33012 int res1 = 0 ;
33013 wxSize temp2 ;
33014 PyObject * obj0 = 0 ;
33015 PyObject * obj1 = 0 ;
33016 char * kwnames[] = {
33017 (char *) "self",(char *) "minSize", NULL
33018 };
33019
33020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33022 if (!SWIG_IsOK(res1)) {
33023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33024 }
33025 arg1 = reinterpret_cast< wxWindow * >(argp1);
33026 {
33027 arg2 = &temp2;
33028 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33029 }
33030 {
33031 PyThreadState* __tstate = wxPyBeginAllowThreads();
33032 (arg1)->SetMinSize((wxSize const &)*arg2);
33033 wxPyEndAllowThreads(__tstate);
33034 if (PyErr_Occurred()) SWIG_fail;
33035 }
33036 resultobj = SWIG_Py_Void();
33037 return resultobj;
33038 fail:
33039 return NULL;
33040 }
33041
33042
33043 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33044 PyObject *resultobj = 0;
33045 wxWindow *arg1 = (wxWindow *) 0 ;
33046 wxSize *arg2 = 0 ;
33047 void *argp1 = 0 ;
33048 int res1 = 0 ;
33049 wxSize temp2 ;
33050 PyObject * obj0 = 0 ;
33051 PyObject * obj1 = 0 ;
33052 char * kwnames[] = {
33053 (char *) "self",(char *) "maxSize", NULL
33054 };
33055
33056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33058 if (!SWIG_IsOK(res1)) {
33059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33060 }
33061 arg1 = reinterpret_cast< wxWindow * >(argp1);
33062 {
33063 arg2 = &temp2;
33064 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33065 }
33066 {
33067 PyThreadState* __tstate = wxPyBeginAllowThreads();
33068 (arg1)->SetMaxSize((wxSize const &)*arg2);
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 resultobj = SWIG_Py_Void();
33073 return resultobj;
33074 fail:
33075 return NULL;
33076 }
33077
33078
33079 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33080 PyObject *resultobj = 0;
33081 wxWindow *arg1 = (wxWindow *) 0 ;
33082 int result;
33083 void *argp1 = 0 ;
33084 int res1 = 0 ;
33085 PyObject *swig_obj[1] ;
33086
33087 if (!args) SWIG_fail;
33088 swig_obj[0] = args;
33089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33090 if (!SWIG_IsOK(res1)) {
33091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33092 }
33093 arg1 = reinterpret_cast< wxWindow * >(argp1);
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 resultobj = SWIG_From_int(static_cast< int >(result));
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33108 PyObject *resultobj = 0;
33109 wxWindow *arg1 = (wxWindow *) 0 ;
33110 int result;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 PyObject *swig_obj[1] ;
33114
33115 if (!args) SWIG_fail;
33116 swig_obj[0] = args;
33117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33118 if (!SWIG_IsOK(res1)) {
33119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33120 }
33121 arg1 = reinterpret_cast< wxWindow * >(argp1);
33122 {
33123 PyThreadState* __tstate = wxPyBeginAllowThreads();
33124 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33125 wxPyEndAllowThreads(__tstate);
33126 if (PyErr_Occurred()) SWIG_fail;
33127 }
33128 resultobj = SWIG_From_int(static_cast< int >(result));
33129 return resultobj;
33130 fail:
33131 return NULL;
33132 }
33133
33134
33135 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33136 PyObject *resultobj = 0;
33137 wxWindow *arg1 = (wxWindow *) 0 ;
33138 int result;
33139 void *argp1 = 0 ;
33140 int res1 = 0 ;
33141 PyObject *swig_obj[1] ;
33142
33143 if (!args) SWIG_fail;
33144 swig_obj[0] = args;
33145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33146 if (!SWIG_IsOK(res1)) {
33147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33148 }
33149 arg1 = reinterpret_cast< wxWindow * >(argp1);
33150 {
33151 PyThreadState* __tstate = wxPyBeginAllowThreads();
33152 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33153 wxPyEndAllowThreads(__tstate);
33154 if (PyErr_Occurred()) SWIG_fail;
33155 }
33156 resultobj = SWIG_From_int(static_cast< int >(result));
33157 return resultobj;
33158 fail:
33159 return NULL;
33160 }
33161
33162
33163 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33164 PyObject *resultobj = 0;
33165 wxWindow *arg1 = (wxWindow *) 0 ;
33166 int result;
33167 void *argp1 = 0 ;
33168 int res1 = 0 ;
33169 PyObject *swig_obj[1] ;
33170
33171 if (!args) SWIG_fail;
33172 swig_obj[0] = args;
33173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33174 if (!SWIG_IsOK(res1)) {
33175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33176 }
33177 arg1 = reinterpret_cast< wxWindow * >(argp1);
33178 {
33179 PyThreadState* __tstate = wxPyBeginAllowThreads();
33180 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33181 wxPyEndAllowThreads(__tstate);
33182 if (PyErr_Occurred()) SWIG_fail;
33183 }
33184 resultobj = SWIG_From_int(static_cast< int >(result));
33185 return resultobj;
33186 fail:
33187 return NULL;
33188 }
33189
33190
33191 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33192 PyObject *resultobj = 0;
33193 wxWindow *arg1 = (wxWindow *) 0 ;
33194 wxSize *arg2 = 0 ;
33195 void *argp1 = 0 ;
33196 int res1 = 0 ;
33197 wxSize temp2 ;
33198 PyObject * obj0 = 0 ;
33199 PyObject * obj1 = 0 ;
33200 char * kwnames[] = {
33201 (char *) "self",(char *) "size", NULL
33202 };
33203
33204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33206 if (!SWIG_IsOK(res1)) {
33207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33208 }
33209 arg1 = reinterpret_cast< wxWindow * >(argp1);
33210 {
33211 arg2 = &temp2;
33212 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33213 }
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33217 wxPyEndAllowThreads(__tstate);
33218 if (PyErr_Occurred()) SWIG_fail;
33219 }
33220 resultobj = SWIG_Py_Void();
33221 return resultobj;
33222 fail:
33223 return NULL;
33224 }
33225
33226
33227 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 int arg2 ;
33231 int arg3 ;
33232 void *argp1 = 0 ;
33233 int res1 = 0 ;
33234 int val2 ;
33235 int ecode2 = 0 ;
33236 int val3 ;
33237 int ecode3 = 0 ;
33238 PyObject * obj0 = 0 ;
33239 PyObject * obj1 = 0 ;
33240 PyObject * obj2 = 0 ;
33241 char * kwnames[] = {
33242 (char *) "self",(char *) "w",(char *) "h", NULL
33243 };
33244
33245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33247 if (!SWIG_IsOK(res1)) {
33248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33249 }
33250 arg1 = reinterpret_cast< wxWindow * >(argp1);
33251 ecode2 = SWIG_AsVal_int(obj1, &val2);
33252 if (!SWIG_IsOK(ecode2)) {
33253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33254 }
33255 arg2 = static_cast< int >(val2);
33256 ecode3 = SWIG_AsVal_int(obj2, &val3);
33257 if (!SWIG_IsOK(ecode3)) {
33258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33259 }
33260 arg3 = static_cast< int >(val3);
33261 {
33262 PyThreadState* __tstate = wxPyBeginAllowThreads();
33263 (arg1)->SetVirtualSize(arg2,arg3);
33264 wxPyEndAllowThreads(__tstate);
33265 if (PyErr_Occurred()) SWIG_fail;
33266 }
33267 resultobj = SWIG_Py_Void();
33268 return resultobj;
33269 fail:
33270 return NULL;
33271 }
33272
33273
33274 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33275 PyObject *resultobj = 0;
33276 wxWindow *arg1 = (wxWindow *) 0 ;
33277 wxSize result;
33278 void *argp1 = 0 ;
33279 int res1 = 0 ;
33280 PyObject *swig_obj[1] ;
33281
33282 if (!args) SWIG_fail;
33283 swig_obj[0] = args;
33284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33285 if (!SWIG_IsOK(res1)) {
33286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33287 }
33288 arg1 = reinterpret_cast< wxWindow * >(argp1);
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 result = ((wxWindow const *)arg1)->GetVirtualSize();
33292 wxPyEndAllowThreads(__tstate);
33293 if (PyErr_Occurred()) SWIG_fail;
33294 }
33295 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33296 return resultobj;
33297 fail:
33298 return NULL;
33299 }
33300
33301
33302 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33303 PyObject *resultobj = 0;
33304 wxWindow *arg1 = (wxWindow *) 0 ;
33305 int *arg2 = (int *) 0 ;
33306 int *arg3 = (int *) 0 ;
33307 void *argp1 = 0 ;
33308 int res1 = 0 ;
33309 int temp2 ;
33310 int res2 = SWIG_TMPOBJ ;
33311 int temp3 ;
33312 int res3 = SWIG_TMPOBJ ;
33313 PyObject *swig_obj[1] ;
33314
33315 arg2 = &temp2;
33316 arg3 = &temp3;
33317 if (!args) SWIG_fail;
33318 swig_obj[0] = args;
33319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33320 if (!SWIG_IsOK(res1)) {
33321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33322 }
33323 arg1 = reinterpret_cast< wxWindow * >(argp1);
33324 {
33325 PyThreadState* __tstate = wxPyBeginAllowThreads();
33326 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33327 wxPyEndAllowThreads(__tstate);
33328 if (PyErr_Occurred()) SWIG_fail;
33329 }
33330 resultobj = SWIG_Py_Void();
33331 if (SWIG_IsTmpObj(res2)) {
33332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33333 } else {
33334 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33336 }
33337 if (SWIG_IsTmpObj(res3)) {
33338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33339 } else {
33340 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33342 }
33343 return resultobj;
33344 fail:
33345 return NULL;
33346 }
33347
33348
33349 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33350 PyObject *resultobj = 0;
33351 wxWindow *arg1 = (wxWindow *) 0 ;
33352 wxSize result;
33353 void *argp1 = 0 ;
33354 int res1 = 0 ;
33355 PyObject *swig_obj[1] ;
33356
33357 if (!args) SWIG_fail;
33358 swig_obj[0] = args;
33359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33360 if (!SWIG_IsOK(res1)) {
33361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33362 }
33363 arg1 = reinterpret_cast< wxWindow * >(argp1);
33364 {
33365 PyThreadState* __tstate = wxPyBeginAllowThreads();
33366 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33367 wxPyEndAllowThreads(__tstate);
33368 if (PyErr_Occurred()) SWIG_fail;
33369 }
33370 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33371 return resultobj;
33372 fail:
33373 return NULL;
33374 }
33375
33376
33377 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33378 PyObject *resultobj = 0;
33379 wxWindow *arg1 = (wxWindow *) 0 ;
33380 bool arg2 = (bool) true ;
33381 bool result;
33382 void *argp1 = 0 ;
33383 int res1 = 0 ;
33384 bool val2 ;
33385 int ecode2 = 0 ;
33386 PyObject * obj0 = 0 ;
33387 PyObject * obj1 = 0 ;
33388 char * kwnames[] = {
33389 (char *) "self",(char *) "show", NULL
33390 };
33391
33392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33394 if (!SWIG_IsOK(res1)) {
33395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33396 }
33397 arg1 = reinterpret_cast< wxWindow * >(argp1);
33398 if (obj1) {
33399 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33400 if (!SWIG_IsOK(ecode2)) {
33401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33402 }
33403 arg2 = static_cast< bool >(val2);
33404 }
33405 {
33406 PyThreadState* __tstate = wxPyBeginAllowThreads();
33407 result = (bool)(arg1)->Show(arg2);
33408 wxPyEndAllowThreads(__tstate);
33409 if (PyErr_Occurred()) SWIG_fail;
33410 }
33411 {
33412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33413 }
33414 return resultobj;
33415 fail:
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33421 PyObject *resultobj = 0;
33422 wxWindow *arg1 = (wxWindow *) 0 ;
33423 bool result;
33424 void *argp1 = 0 ;
33425 int res1 = 0 ;
33426 PyObject *swig_obj[1] ;
33427
33428 if (!args) SWIG_fail;
33429 swig_obj[0] = args;
33430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33431 if (!SWIG_IsOK(res1)) {
33432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33433 }
33434 arg1 = reinterpret_cast< wxWindow * >(argp1);
33435 {
33436 PyThreadState* __tstate = wxPyBeginAllowThreads();
33437 result = (bool)(arg1)->Hide();
33438 wxPyEndAllowThreads(__tstate);
33439 if (PyErr_Occurred()) SWIG_fail;
33440 }
33441 {
33442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33443 }
33444 return resultobj;
33445 fail:
33446 return NULL;
33447 }
33448
33449
33450 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33451 PyObject *resultobj = 0;
33452 wxWindow *arg1 = (wxWindow *) 0 ;
33453 bool arg2 = (bool) true ;
33454 bool result;
33455 void *argp1 = 0 ;
33456 int res1 = 0 ;
33457 bool val2 ;
33458 int ecode2 = 0 ;
33459 PyObject * obj0 = 0 ;
33460 PyObject * obj1 = 0 ;
33461 char * kwnames[] = {
33462 (char *) "self",(char *) "enable", NULL
33463 };
33464
33465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33467 if (!SWIG_IsOK(res1)) {
33468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33469 }
33470 arg1 = reinterpret_cast< wxWindow * >(argp1);
33471 if (obj1) {
33472 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33473 if (!SWIG_IsOK(ecode2)) {
33474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33475 }
33476 arg2 = static_cast< bool >(val2);
33477 }
33478 {
33479 PyThreadState* __tstate = wxPyBeginAllowThreads();
33480 result = (bool)(arg1)->Enable(arg2);
33481 wxPyEndAllowThreads(__tstate);
33482 if (PyErr_Occurred()) SWIG_fail;
33483 }
33484 {
33485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33486 }
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33494 PyObject *resultobj = 0;
33495 wxWindow *arg1 = (wxWindow *) 0 ;
33496 bool result;
33497 void *argp1 = 0 ;
33498 int res1 = 0 ;
33499 PyObject *swig_obj[1] ;
33500
33501 if (!args) SWIG_fail;
33502 swig_obj[0] = args;
33503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33504 if (!SWIG_IsOK(res1)) {
33505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33506 }
33507 arg1 = reinterpret_cast< wxWindow * >(argp1);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 result = (bool)(arg1)->Disable();
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 {
33515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33516 }
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33524 PyObject *resultobj = 0;
33525 wxWindow *arg1 = (wxWindow *) 0 ;
33526 bool result;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 PyObject *swig_obj[1] ;
33530
33531 if (!args) SWIG_fail;
33532 swig_obj[0] = args;
33533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 {
33539 PyThreadState* __tstate = wxPyBeginAllowThreads();
33540 result = (bool)((wxWindow const *)arg1)->IsShown();
33541 wxPyEndAllowThreads(__tstate);
33542 if (PyErr_Occurred()) SWIG_fail;
33543 }
33544 {
33545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33546 }
33547 return resultobj;
33548 fail:
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33554 PyObject *resultobj = 0;
33555 wxWindow *arg1 = (wxWindow *) 0 ;
33556 bool result;
33557 void *argp1 = 0 ;
33558 int res1 = 0 ;
33559 PyObject *swig_obj[1] ;
33560
33561 if (!args) SWIG_fail;
33562 swig_obj[0] = args;
33563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33564 if (!SWIG_IsOK(res1)) {
33565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33566 }
33567 arg1 = reinterpret_cast< wxWindow * >(argp1);
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 {
33575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33576 }
33577 return resultobj;
33578 fail:
33579 return NULL;
33580 }
33581
33582
33583 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33584 PyObject *resultobj = 0;
33585 wxWindow *arg1 = (wxWindow *) 0 ;
33586 bool result;
33587 void *argp1 = 0 ;
33588 int res1 = 0 ;
33589 PyObject *swig_obj[1] ;
33590
33591 if (!args) SWIG_fail;
33592 swig_obj[0] = args;
33593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33594 if (!SWIG_IsOK(res1)) {
33595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33596 }
33597 arg1 = reinterpret_cast< wxWindow * >(argp1);
33598 {
33599 PyThreadState* __tstate = wxPyBeginAllowThreads();
33600 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 {
33605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33606 }
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33614 PyObject *resultobj = 0;
33615 wxWindow *arg1 = (wxWindow *) 0 ;
33616 long arg2 ;
33617 void *argp1 = 0 ;
33618 int res1 = 0 ;
33619 long val2 ;
33620 int ecode2 = 0 ;
33621 PyObject * obj0 = 0 ;
33622 PyObject * obj1 = 0 ;
33623 char * kwnames[] = {
33624 (char *) "self",(char *) "style", NULL
33625 };
33626
33627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33629 if (!SWIG_IsOK(res1)) {
33630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33631 }
33632 arg1 = reinterpret_cast< wxWindow * >(argp1);
33633 ecode2 = SWIG_AsVal_long(obj1, &val2);
33634 if (!SWIG_IsOK(ecode2)) {
33635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33636 }
33637 arg2 = static_cast< long >(val2);
33638 {
33639 PyThreadState* __tstate = wxPyBeginAllowThreads();
33640 (arg1)->SetWindowStyleFlag(arg2);
33641 wxPyEndAllowThreads(__tstate);
33642 if (PyErr_Occurred()) SWIG_fail;
33643 }
33644 resultobj = SWIG_Py_Void();
33645 return resultobj;
33646 fail:
33647 return NULL;
33648 }
33649
33650
33651 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33652 PyObject *resultobj = 0;
33653 wxWindow *arg1 = (wxWindow *) 0 ;
33654 long result;
33655 void *argp1 = 0 ;
33656 int res1 = 0 ;
33657 PyObject *swig_obj[1] ;
33658
33659 if (!args) SWIG_fail;
33660 swig_obj[0] = args;
33661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33662 if (!SWIG_IsOK(res1)) {
33663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33664 }
33665 arg1 = reinterpret_cast< wxWindow * >(argp1);
33666 {
33667 PyThreadState* __tstate = wxPyBeginAllowThreads();
33668 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33669 wxPyEndAllowThreads(__tstate);
33670 if (PyErr_Occurred()) SWIG_fail;
33671 }
33672 resultobj = SWIG_From_long(static_cast< long >(result));
33673 return resultobj;
33674 fail:
33675 return NULL;
33676 }
33677
33678
33679 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33680 PyObject *resultobj = 0;
33681 wxWindow *arg1 = (wxWindow *) 0 ;
33682 int arg2 ;
33683 bool result;
33684 void *argp1 = 0 ;
33685 int res1 = 0 ;
33686 int val2 ;
33687 int ecode2 = 0 ;
33688 PyObject * obj0 = 0 ;
33689 PyObject * obj1 = 0 ;
33690 char * kwnames[] = {
33691 (char *) "self",(char *) "flag", NULL
33692 };
33693
33694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33696 if (!SWIG_IsOK(res1)) {
33697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33698 }
33699 arg1 = reinterpret_cast< wxWindow * >(argp1);
33700 ecode2 = SWIG_AsVal_int(obj1, &val2);
33701 if (!SWIG_IsOK(ecode2)) {
33702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33703 }
33704 arg2 = static_cast< int >(val2);
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 {
33712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33713 }
33714 return resultobj;
33715 fail:
33716 return NULL;
33717 }
33718
33719
33720 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33721 PyObject *resultobj = 0;
33722 wxWindow *arg1 = (wxWindow *) 0 ;
33723 bool result;
33724 void *argp1 = 0 ;
33725 int res1 = 0 ;
33726 PyObject *swig_obj[1] ;
33727
33728 if (!args) SWIG_fail;
33729 swig_obj[0] = args;
33730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33731 if (!SWIG_IsOK(res1)) {
33732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33733 }
33734 arg1 = reinterpret_cast< wxWindow * >(argp1);
33735 {
33736 PyThreadState* __tstate = wxPyBeginAllowThreads();
33737 result = (bool)((wxWindow const *)arg1)->IsRetained();
33738 wxPyEndAllowThreads(__tstate);
33739 if (PyErr_Occurred()) SWIG_fail;
33740 }
33741 {
33742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33743 }
33744 return resultobj;
33745 fail:
33746 return NULL;
33747 }
33748
33749
33750 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33751 PyObject *resultobj = 0;
33752 wxWindow *arg1 = (wxWindow *) 0 ;
33753 long arg2 ;
33754 void *argp1 = 0 ;
33755 int res1 = 0 ;
33756 long val2 ;
33757 int ecode2 = 0 ;
33758 PyObject * obj0 = 0 ;
33759 PyObject * obj1 = 0 ;
33760 char * kwnames[] = {
33761 (char *) "self",(char *) "exStyle", NULL
33762 };
33763
33764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33766 if (!SWIG_IsOK(res1)) {
33767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33768 }
33769 arg1 = reinterpret_cast< wxWindow * >(argp1);
33770 ecode2 = SWIG_AsVal_long(obj1, &val2);
33771 if (!SWIG_IsOK(ecode2)) {
33772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33773 }
33774 arg2 = static_cast< long >(val2);
33775 {
33776 PyThreadState* __tstate = wxPyBeginAllowThreads();
33777 (arg1)->SetExtraStyle(arg2);
33778 wxPyEndAllowThreads(__tstate);
33779 if (PyErr_Occurred()) SWIG_fail;
33780 }
33781 resultobj = SWIG_Py_Void();
33782 return resultobj;
33783 fail:
33784 return NULL;
33785 }
33786
33787
33788 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33789 PyObject *resultobj = 0;
33790 wxWindow *arg1 = (wxWindow *) 0 ;
33791 long result;
33792 void *argp1 = 0 ;
33793 int res1 = 0 ;
33794 PyObject *swig_obj[1] ;
33795
33796 if (!args) SWIG_fail;
33797 swig_obj[0] = args;
33798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33801 }
33802 arg1 = reinterpret_cast< wxWindow * >(argp1);
33803 {
33804 PyThreadState* __tstate = wxPyBeginAllowThreads();
33805 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33806 wxPyEndAllowThreads(__tstate);
33807 if (PyErr_Occurred()) SWIG_fail;
33808 }
33809 resultobj = SWIG_From_long(static_cast< long >(result));
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 bool arg2 = (bool) true ;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 bool val2 ;
33823 int ecode2 = 0 ;
33824 PyObject * obj0 = 0 ;
33825 PyObject * obj1 = 0 ;
33826 char * kwnames[] = {
33827 (char *) "self",(char *) "modal", NULL
33828 };
33829
33830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33832 if (!SWIG_IsOK(res1)) {
33833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33834 }
33835 arg1 = reinterpret_cast< wxWindow * >(argp1);
33836 if (obj1) {
33837 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33838 if (!SWIG_IsOK(ecode2)) {
33839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33840 }
33841 arg2 = static_cast< bool >(val2);
33842 }
33843 {
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 (arg1)->MakeModal(arg2);
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 resultobj = SWIG_Py_Void();
33850 return resultobj;
33851 fail:
33852 return NULL;
33853 }
33854
33855
33856 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33857 PyObject *resultobj = 0;
33858 wxWindow *arg1 = (wxWindow *) 0 ;
33859 bool arg2 ;
33860 void *argp1 = 0 ;
33861 int res1 = 0 ;
33862 bool val2 ;
33863 int ecode2 = 0 ;
33864 PyObject * obj0 = 0 ;
33865 PyObject * obj1 = 0 ;
33866 char * kwnames[] = {
33867 (char *) "self",(char *) "enableTheme", NULL
33868 };
33869
33870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33872 if (!SWIG_IsOK(res1)) {
33873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33874 }
33875 arg1 = reinterpret_cast< wxWindow * >(argp1);
33876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33877 if (!SWIG_IsOK(ecode2)) {
33878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33879 }
33880 arg2 = static_cast< bool >(val2);
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 (arg1)->SetThemeEnabled(arg2);
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 resultobj = SWIG_Py_Void();
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33895 PyObject *resultobj = 0;
33896 wxWindow *arg1 = (wxWindow *) 0 ;
33897 bool result;
33898 void *argp1 = 0 ;
33899 int res1 = 0 ;
33900 PyObject *swig_obj[1] ;
33901
33902 if (!args) SWIG_fail;
33903 swig_obj[0] = args;
33904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33905 if (!SWIG_IsOK(res1)) {
33906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33907 }
33908 arg1 = reinterpret_cast< wxWindow * >(argp1);
33909 {
33910 PyThreadState* __tstate = wxPyBeginAllowThreads();
33911 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33912 wxPyEndAllowThreads(__tstate);
33913 if (PyErr_Occurred()) SWIG_fail;
33914 }
33915 {
33916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33917 }
33918 return resultobj;
33919 fail:
33920 return NULL;
33921 }
33922
33923
33924 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33925 PyObject *resultobj = 0;
33926 wxWindow *arg1 = (wxWindow *) 0 ;
33927 void *argp1 = 0 ;
33928 int res1 = 0 ;
33929 PyObject *swig_obj[1] ;
33930
33931 if (!args) SWIG_fail;
33932 swig_obj[0] = args;
33933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33934 if (!SWIG_IsOK(res1)) {
33935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33936 }
33937 arg1 = reinterpret_cast< wxWindow * >(argp1);
33938 {
33939 PyThreadState* __tstate = wxPyBeginAllowThreads();
33940 (arg1)->SetFocus();
33941 wxPyEndAllowThreads(__tstate);
33942 if (PyErr_Occurred()) SWIG_fail;
33943 }
33944 resultobj = SWIG_Py_Void();
33945 return resultobj;
33946 fail:
33947 return NULL;
33948 }
33949
33950
33951 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33952 PyObject *resultobj = 0;
33953 wxWindow *arg1 = (wxWindow *) 0 ;
33954 void *argp1 = 0 ;
33955 int res1 = 0 ;
33956 PyObject *swig_obj[1] ;
33957
33958 if (!args) SWIG_fail;
33959 swig_obj[0] = args;
33960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33961 if (!SWIG_IsOK(res1)) {
33962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33963 }
33964 arg1 = reinterpret_cast< wxWindow * >(argp1);
33965 {
33966 PyThreadState* __tstate = wxPyBeginAllowThreads();
33967 (arg1)->SetFocusFromKbd();
33968 wxPyEndAllowThreads(__tstate);
33969 if (PyErr_Occurred()) SWIG_fail;
33970 }
33971 resultobj = SWIG_Py_Void();
33972 return resultobj;
33973 fail:
33974 return NULL;
33975 }
33976
33977
33978 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33979 PyObject *resultobj = 0;
33980 wxWindow *result = 0 ;
33981
33982 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33983 {
33984 if (!wxPyCheckForApp()) SWIG_fail;
33985 PyThreadState* __tstate = wxPyBeginAllowThreads();
33986 result = (wxWindow *)wxWindow::FindFocus();
33987 wxPyEndAllowThreads(__tstate);
33988 if (PyErr_Occurred()) SWIG_fail;
33989 }
33990 {
33991 resultobj = wxPyMake_wxObject(result, 0);
33992 }
33993 return resultobj;
33994 fail:
33995 return NULL;
33996 }
33997
33998
33999 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34000 PyObject *resultobj = 0;
34001 wxWindow *arg1 = (wxWindow *) 0 ;
34002 bool result;
34003 void *argp1 = 0 ;
34004 int res1 = 0 ;
34005 PyObject *swig_obj[1] ;
34006
34007 if (!args) SWIG_fail;
34008 swig_obj[0] = args;
34009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34010 if (!SWIG_IsOK(res1)) {
34011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
34012 }
34013 arg1 = reinterpret_cast< wxWindow * >(argp1);
34014 {
34015 PyThreadState* __tstate = wxPyBeginAllowThreads();
34016 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34017 wxPyEndAllowThreads(__tstate);
34018 if (PyErr_Occurred()) SWIG_fail;
34019 }
34020 {
34021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34022 }
34023 return resultobj;
34024 fail:
34025 return NULL;
34026 }
34027
34028
34029 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34030 PyObject *resultobj = 0;
34031 wxWindow *arg1 = (wxWindow *) 0 ;
34032 bool result;
34033 void *argp1 = 0 ;
34034 int res1 = 0 ;
34035 PyObject *swig_obj[1] ;
34036
34037 if (!args) SWIG_fail;
34038 swig_obj[0] = args;
34039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34040 if (!SWIG_IsOK(res1)) {
34041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34042 }
34043 arg1 = reinterpret_cast< wxWindow * >(argp1);
34044 {
34045 PyThreadState* __tstate = wxPyBeginAllowThreads();
34046 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34047 wxPyEndAllowThreads(__tstate);
34048 if (PyErr_Occurred()) SWIG_fail;
34049 }
34050 {
34051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34052 }
34053 return resultobj;
34054 fail:
34055 return NULL;
34056 }
34057
34058
34059 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34060 PyObject *resultobj = 0;
34061 wxWindow *arg1 = (wxWindow *) 0 ;
34062 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34063 bool result;
34064 void *argp1 = 0 ;
34065 int res1 = 0 ;
34066 int val2 ;
34067 int ecode2 = 0 ;
34068 PyObject * obj0 = 0 ;
34069 PyObject * obj1 = 0 ;
34070 char * kwnames[] = {
34071 (char *) "self",(char *) "flags", NULL
34072 };
34073
34074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34076 if (!SWIG_IsOK(res1)) {
34077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34078 }
34079 arg1 = reinterpret_cast< wxWindow * >(argp1);
34080 if (obj1) {
34081 ecode2 = SWIG_AsVal_int(obj1, &val2);
34082 if (!SWIG_IsOK(ecode2)) {
34083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34084 }
34085 arg2 = static_cast< int >(val2);
34086 }
34087 {
34088 PyThreadState* __tstate = wxPyBeginAllowThreads();
34089 result = (bool)(arg1)->Navigate(arg2);
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 {
34094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34095 }
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34103 PyObject *resultobj = 0;
34104 wxWindow *arg1 = (wxWindow *) 0 ;
34105 wxWindow *arg2 = (wxWindow *) 0 ;
34106 void *argp1 = 0 ;
34107 int res1 = 0 ;
34108 void *argp2 = 0 ;
34109 int res2 = 0 ;
34110 PyObject * obj0 = 0 ;
34111 PyObject * obj1 = 0 ;
34112 char * kwnames[] = {
34113 (char *) "self",(char *) "win", NULL
34114 };
34115
34116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34118 if (!SWIG_IsOK(res1)) {
34119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34120 }
34121 arg1 = reinterpret_cast< wxWindow * >(argp1);
34122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34123 if (!SWIG_IsOK(res2)) {
34124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34125 }
34126 arg2 = reinterpret_cast< wxWindow * >(argp2);
34127 {
34128 PyThreadState* __tstate = wxPyBeginAllowThreads();
34129 (arg1)->MoveAfterInTabOrder(arg2);
34130 wxPyEndAllowThreads(__tstate);
34131 if (PyErr_Occurred()) SWIG_fail;
34132 }
34133 resultobj = SWIG_Py_Void();
34134 return resultobj;
34135 fail:
34136 return NULL;
34137 }
34138
34139
34140 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34141 PyObject *resultobj = 0;
34142 wxWindow *arg1 = (wxWindow *) 0 ;
34143 wxWindow *arg2 = (wxWindow *) 0 ;
34144 void *argp1 = 0 ;
34145 int res1 = 0 ;
34146 void *argp2 = 0 ;
34147 int res2 = 0 ;
34148 PyObject * obj0 = 0 ;
34149 PyObject * obj1 = 0 ;
34150 char * kwnames[] = {
34151 (char *) "self",(char *) "win", NULL
34152 };
34153
34154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34156 if (!SWIG_IsOK(res1)) {
34157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34158 }
34159 arg1 = reinterpret_cast< wxWindow * >(argp1);
34160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34161 if (!SWIG_IsOK(res2)) {
34162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34163 }
34164 arg2 = reinterpret_cast< wxWindow * >(argp2);
34165 {
34166 PyThreadState* __tstate = wxPyBeginAllowThreads();
34167 (arg1)->MoveBeforeInTabOrder(arg2);
34168 wxPyEndAllowThreads(__tstate);
34169 if (PyErr_Occurred()) SWIG_fail;
34170 }
34171 resultobj = SWIG_Py_Void();
34172 return resultobj;
34173 fail:
34174 return NULL;
34175 }
34176
34177
34178 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34179 PyObject *resultobj = 0;
34180 wxWindow *arg1 = (wxWindow *) 0 ;
34181 PyObject *result = 0 ;
34182 void *argp1 = 0 ;
34183 int res1 = 0 ;
34184 PyObject *swig_obj[1] ;
34185
34186 if (!args) SWIG_fail;
34187 swig_obj[0] = args;
34188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34189 if (!SWIG_IsOK(res1)) {
34190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34191 }
34192 arg1 = reinterpret_cast< wxWindow * >(argp1);
34193 {
34194 PyThreadState* __tstate = wxPyBeginAllowThreads();
34195 result = (PyObject *)wxWindow_GetChildren(arg1);
34196 wxPyEndAllowThreads(__tstate);
34197 if (PyErr_Occurred()) SWIG_fail;
34198 }
34199 resultobj = result;
34200 return resultobj;
34201 fail:
34202 return NULL;
34203 }
34204
34205
34206 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34207 PyObject *resultobj = 0;
34208 wxWindow *arg1 = (wxWindow *) 0 ;
34209 wxWindow *result = 0 ;
34210 void *argp1 = 0 ;
34211 int res1 = 0 ;
34212 PyObject *swig_obj[1] ;
34213
34214 if (!args) SWIG_fail;
34215 swig_obj[0] = args;
34216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34217 if (!SWIG_IsOK(res1)) {
34218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34219 }
34220 arg1 = reinterpret_cast< wxWindow * >(argp1);
34221 {
34222 PyThreadState* __tstate = wxPyBeginAllowThreads();
34223 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34224 wxPyEndAllowThreads(__tstate);
34225 if (PyErr_Occurred()) SWIG_fail;
34226 }
34227 {
34228 resultobj = wxPyMake_wxObject(result, 0);
34229 }
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34237 PyObject *resultobj = 0;
34238 wxWindow *arg1 = (wxWindow *) 0 ;
34239 wxWindow *result = 0 ;
34240 void *argp1 = 0 ;
34241 int res1 = 0 ;
34242 PyObject *swig_obj[1] ;
34243
34244 if (!args) SWIG_fail;
34245 swig_obj[0] = args;
34246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34247 if (!SWIG_IsOK(res1)) {
34248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34249 }
34250 arg1 = reinterpret_cast< wxWindow * >(argp1);
34251 {
34252 PyThreadState* __tstate = wxPyBeginAllowThreads();
34253 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34254 wxPyEndAllowThreads(__tstate);
34255 if (PyErr_Occurred()) SWIG_fail;
34256 }
34257 {
34258 resultobj = wxPyMake_wxObject(result, 0);
34259 }
34260 return resultobj;
34261 fail:
34262 return NULL;
34263 }
34264
34265
34266 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34267 PyObject *resultobj = 0;
34268 wxWindow *arg1 = (wxWindow *) 0 ;
34269 bool result;
34270 void *argp1 = 0 ;
34271 int res1 = 0 ;
34272 PyObject *swig_obj[1] ;
34273
34274 if (!args) SWIG_fail;
34275 swig_obj[0] = args;
34276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34277 if (!SWIG_IsOK(res1)) {
34278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34279 }
34280 arg1 = reinterpret_cast< wxWindow * >(argp1);
34281 {
34282 PyThreadState* __tstate = wxPyBeginAllowThreads();
34283 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34284 wxPyEndAllowThreads(__tstate);
34285 if (PyErr_Occurred()) SWIG_fail;
34286 }
34287 {
34288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34289 }
34290 return resultobj;
34291 fail:
34292 return NULL;
34293 }
34294
34295
34296 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34297 PyObject *resultobj = 0;
34298 wxWindow *arg1 = (wxWindow *) 0 ;
34299 wxWindow *arg2 = (wxWindow *) 0 ;
34300 bool result;
34301 void *argp1 = 0 ;
34302 int res1 = 0 ;
34303 void *argp2 = 0 ;
34304 int res2 = 0 ;
34305 PyObject * obj0 = 0 ;
34306 PyObject * obj1 = 0 ;
34307 char * kwnames[] = {
34308 (char *) "self",(char *) "newParent", NULL
34309 };
34310
34311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34313 if (!SWIG_IsOK(res1)) {
34314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34315 }
34316 arg1 = reinterpret_cast< wxWindow * >(argp1);
34317 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34318 if (!SWIG_IsOK(res2)) {
34319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34320 }
34321 arg2 = reinterpret_cast< wxWindow * >(argp2);
34322 {
34323 PyThreadState* __tstate = wxPyBeginAllowThreads();
34324 result = (bool)(arg1)->Reparent(arg2);
34325 wxPyEndAllowThreads(__tstate);
34326 if (PyErr_Occurred()) SWIG_fail;
34327 }
34328 {
34329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34330 }
34331 return resultobj;
34332 fail:
34333 return NULL;
34334 }
34335
34336
34337 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34338 PyObject *resultobj = 0;
34339 wxWindow *arg1 = (wxWindow *) 0 ;
34340 wxWindow *arg2 = (wxWindow *) 0 ;
34341 void *argp1 = 0 ;
34342 int res1 = 0 ;
34343 void *argp2 = 0 ;
34344 int res2 = 0 ;
34345 PyObject * obj0 = 0 ;
34346 PyObject * obj1 = 0 ;
34347 char * kwnames[] = {
34348 (char *) "self",(char *) "child", NULL
34349 };
34350
34351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34353 if (!SWIG_IsOK(res1)) {
34354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34355 }
34356 arg1 = reinterpret_cast< wxWindow * >(argp1);
34357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34358 if (!SWIG_IsOK(res2)) {
34359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34360 }
34361 arg2 = reinterpret_cast< wxWindow * >(argp2);
34362 {
34363 PyThreadState* __tstate = wxPyBeginAllowThreads();
34364 (arg1)->AddChild(arg2);
34365 wxPyEndAllowThreads(__tstate);
34366 if (PyErr_Occurred()) SWIG_fail;
34367 }
34368 resultobj = SWIG_Py_Void();
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34376 PyObject *resultobj = 0;
34377 wxWindow *arg1 = (wxWindow *) 0 ;
34378 wxWindow *arg2 = (wxWindow *) 0 ;
34379 void *argp1 = 0 ;
34380 int res1 = 0 ;
34381 void *argp2 = 0 ;
34382 int res2 = 0 ;
34383 PyObject * obj0 = 0 ;
34384 PyObject * obj1 = 0 ;
34385 char * kwnames[] = {
34386 (char *) "self",(char *) "child", NULL
34387 };
34388
34389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34391 if (!SWIG_IsOK(res1)) {
34392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34393 }
34394 arg1 = reinterpret_cast< wxWindow * >(argp1);
34395 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res2)) {
34397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34398 }
34399 arg2 = reinterpret_cast< wxWindow * >(argp2);
34400 {
34401 PyThreadState* __tstate = wxPyBeginAllowThreads();
34402 (arg1)->RemoveChild(arg2);
34403 wxPyEndAllowThreads(__tstate);
34404 if (PyErr_Occurred()) SWIG_fail;
34405 }
34406 resultobj = SWIG_Py_Void();
34407 return resultobj;
34408 fail:
34409 return NULL;
34410 }
34411
34412
34413 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34414 PyObject *resultobj = 0;
34415 wxWindow *arg1 = (wxWindow *) 0 ;
34416 bool arg2 ;
34417 void *argp1 = 0 ;
34418 int res1 = 0 ;
34419 bool val2 ;
34420 int ecode2 = 0 ;
34421 PyObject * obj0 = 0 ;
34422 PyObject * obj1 = 0 ;
34423 char * kwnames[] = {
34424 (char *) "self",(char *) "on", NULL
34425 };
34426
34427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34429 if (!SWIG_IsOK(res1)) {
34430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34431 }
34432 arg1 = reinterpret_cast< wxWindow * >(argp1);
34433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34434 if (!SWIG_IsOK(ecode2)) {
34435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34436 }
34437 arg2 = static_cast< bool >(val2);
34438 {
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 wxWindow_SetDoubleBuffered(arg1,arg2);
34441 wxPyEndAllowThreads(__tstate);
34442 if (PyErr_Occurred()) SWIG_fail;
34443 }
34444 resultobj = SWIG_Py_Void();
34445 return resultobj;
34446 fail:
34447 return NULL;
34448 }
34449
34450
34451 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34452 PyObject *resultobj = 0;
34453 wxWindow *arg1 = (wxWindow *) 0 ;
34454 long arg2 ;
34455 wxWindow *result = 0 ;
34456 void *argp1 = 0 ;
34457 int res1 = 0 ;
34458 long val2 ;
34459 int ecode2 = 0 ;
34460 PyObject * obj0 = 0 ;
34461 PyObject * obj1 = 0 ;
34462 char * kwnames[] = {
34463 (char *) "self",(char *) "winid", NULL
34464 };
34465
34466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34468 if (!SWIG_IsOK(res1)) {
34469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34470 }
34471 arg1 = reinterpret_cast< wxWindow * >(argp1);
34472 ecode2 = SWIG_AsVal_long(obj1, &val2);
34473 if (!SWIG_IsOK(ecode2)) {
34474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34475 }
34476 arg2 = static_cast< long >(val2);
34477 {
34478 PyThreadState* __tstate = wxPyBeginAllowThreads();
34479 result = (wxWindow *)(arg1)->FindWindow(arg2);
34480 wxPyEndAllowThreads(__tstate);
34481 if (PyErr_Occurred()) SWIG_fail;
34482 }
34483 {
34484 resultobj = wxPyMake_wxObject(result, 0);
34485 }
34486 return resultobj;
34487 fail:
34488 return NULL;
34489 }
34490
34491
34492 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34493 PyObject *resultobj = 0;
34494 wxWindow *arg1 = (wxWindow *) 0 ;
34495 wxString *arg2 = 0 ;
34496 wxWindow *result = 0 ;
34497 void *argp1 = 0 ;
34498 int res1 = 0 ;
34499 bool temp2 = false ;
34500 PyObject * obj0 = 0 ;
34501 PyObject * obj1 = 0 ;
34502 char * kwnames[] = {
34503 (char *) "self",(char *) "name", NULL
34504 };
34505
34506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34508 if (!SWIG_IsOK(res1)) {
34509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34510 }
34511 arg1 = reinterpret_cast< wxWindow * >(argp1);
34512 {
34513 arg2 = wxString_in_helper(obj1);
34514 if (arg2 == NULL) SWIG_fail;
34515 temp2 = true;
34516 }
34517 {
34518 PyThreadState* __tstate = wxPyBeginAllowThreads();
34519 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 {
34524 resultobj = wxPyMake_wxObject(result, 0);
34525 }
34526 {
34527 if (temp2)
34528 delete arg2;
34529 }
34530 return resultobj;
34531 fail:
34532 {
34533 if (temp2)
34534 delete arg2;
34535 }
34536 return NULL;
34537 }
34538
34539
34540 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34541 PyObject *resultobj = 0;
34542 wxWindow *arg1 = (wxWindow *) 0 ;
34543 wxEvtHandler *result = 0 ;
34544 void *argp1 = 0 ;
34545 int res1 = 0 ;
34546 PyObject *swig_obj[1] ;
34547
34548 if (!args) SWIG_fail;
34549 swig_obj[0] = args;
34550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34551 if (!SWIG_IsOK(res1)) {
34552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34553 }
34554 arg1 = reinterpret_cast< wxWindow * >(argp1);
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 {
34562 resultobj = wxPyMake_wxObject(result, 0);
34563 }
34564 return resultobj;
34565 fail:
34566 return NULL;
34567 }
34568
34569
34570 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34571 PyObject *resultobj = 0;
34572 wxWindow *arg1 = (wxWindow *) 0 ;
34573 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34574 void *argp1 = 0 ;
34575 int res1 = 0 ;
34576 void *argp2 = 0 ;
34577 int res2 = 0 ;
34578 PyObject * obj0 = 0 ;
34579 PyObject * obj1 = 0 ;
34580 char * kwnames[] = {
34581 (char *) "self",(char *) "handler", NULL
34582 };
34583
34584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34586 if (!SWIG_IsOK(res1)) {
34587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34588 }
34589 arg1 = reinterpret_cast< wxWindow * >(argp1);
34590 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34591 if (!SWIG_IsOK(res2)) {
34592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34593 }
34594 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 (arg1)->SetEventHandler(arg2);
34598 wxPyEndAllowThreads(__tstate);
34599 if (PyErr_Occurred()) SWIG_fail;
34600 }
34601 resultobj = SWIG_Py_Void();
34602 return resultobj;
34603 fail:
34604 return NULL;
34605 }
34606
34607
34608 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34609 PyObject *resultobj = 0;
34610 wxWindow *arg1 = (wxWindow *) 0 ;
34611 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34612 void *argp1 = 0 ;
34613 int res1 = 0 ;
34614 void *argp2 = 0 ;
34615 int res2 = 0 ;
34616 PyObject * obj0 = 0 ;
34617 PyObject * obj1 = 0 ;
34618 char * kwnames[] = {
34619 (char *) "self",(char *) "handler", NULL
34620 };
34621
34622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34624 if (!SWIG_IsOK(res1)) {
34625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34626 }
34627 arg1 = reinterpret_cast< wxWindow * >(argp1);
34628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34629 if (!SWIG_IsOK(res2)) {
34630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34631 }
34632 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 (arg1)->PushEventHandler(arg2);
34636 wxPyEndAllowThreads(__tstate);
34637 if (PyErr_Occurred()) SWIG_fail;
34638 }
34639 resultobj = SWIG_Py_Void();
34640 return resultobj;
34641 fail:
34642 return NULL;
34643 }
34644
34645
34646 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34647 PyObject *resultobj = 0;
34648 wxWindow *arg1 = (wxWindow *) 0 ;
34649 bool arg2 = (bool) false ;
34650 wxEvtHandler *result = 0 ;
34651 void *argp1 = 0 ;
34652 int res1 = 0 ;
34653 bool val2 ;
34654 int ecode2 = 0 ;
34655 PyObject * obj0 = 0 ;
34656 PyObject * obj1 = 0 ;
34657 char * kwnames[] = {
34658 (char *) "self",(char *) "deleteHandler", NULL
34659 };
34660
34661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34663 if (!SWIG_IsOK(res1)) {
34664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34665 }
34666 arg1 = reinterpret_cast< wxWindow * >(argp1);
34667 if (obj1) {
34668 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34669 if (!SWIG_IsOK(ecode2)) {
34670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34671 }
34672 arg2 = static_cast< bool >(val2);
34673 }
34674 {
34675 PyThreadState* __tstate = wxPyBeginAllowThreads();
34676 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34677 wxPyEndAllowThreads(__tstate);
34678 if (PyErr_Occurred()) SWIG_fail;
34679 }
34680 {
34681 resultobj = wxPyMake_wxObject(result, 0);
34682 }
34683 return resultobj;
34684 fail:
34685 return NULL;
34686 }
34687
34688
34689 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34690 PyObject *resultobj = 0;
34691 wxWindow *arg1 = (wxWindow *) 0 ;
34692 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34693 bool result;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 void *argp2 = 0 ;
34697 int res2 = 0 ;
34698 PyObject * obj0 = 0 ;
34699 PyObject * obj1 = 0 ;
34700 char * kwnames[] = {
34701 (char *) "self",(char *) "handler", NULL
34702 };
34703
34704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34706 if (!SWIG_IsOK(res1)) {
34707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34708 }
34709 arg1 = reinterpret_cast< wxWindow * >(argp1);
34710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34711 if (!SWIG_IsOK(res2)) {
34712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34713 }
34714 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34715 {
34716 PyThreadState* __tstate = wxPyBeginAllowThreads();
34717 result = (bool)(arg1)->RemoveEventHandler(arg2);
34718 wxPyEndAllowThreads(__tstate);
34719 if (PyErr_Occurred()) SWIG_fail;
34720 }
34721 {
34722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34723 }
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34731 PyObject *resultobj = 0;
34732 wxWindow *arg1 = (wxWindow *) 0 ;
34733 wxValidator *arg2 = 0 ;
34734 void *argp1 = 0 ;
34735 int res1 = 0 ;
34736 void *argp2 = 0 ;
34737 int res2 = 0 ;
34738 PyObject * obj0 = 0 ;
34739 PyObject * obj1 = 0 ;
34740 char * kwnames[] = {
34741 (char *) "self",(char *) "validator", NULL
34742 };
34743
34744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34746 if (!SWIG_IsOK(res1)) {
34747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34748 }
34749 arg1 = reinterpret_cast< wxWindow * >(argp1);
34750 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34751 if (!SWIG_IsOK(res2)) {
34752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34753 }
34754 if (!argp2) {
34755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34756 }
34757 arg2 = reinterpret_cast< wxValidator * >(argp2);
34758 {
34759 PyThreadState* __tstate = wxPyBeginAllowThreads();
34760 (arg1)->SetValidator((wxValidator const &)*arg2);
34761 wxPyEndAllowThreads(__tstate);
34762 if (PyErr_Occurred()) SWIG_fail;
34763 }
34764 resultobj = SWIG_Py_Void();
34765 return resultobj;
34766 fail:
34767 return NULL;
34768 }
34769
34770
34771 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34772 PyObject *resultobj = 0;
34773 wxWindow *arg1 = (wxWindow *) 0 ;
34774 wxValidator *result = 0 ;
34775 void *argp1 = 0 ;
34776 int res1 = 0 ;
34777 PyObject *swig_obj[1] ;
34778
34779 if (!args) SWIG_fail;
34780 swig_obj[0] = args;
34781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34782 if (!SWIG_IsOK(res1)) {
34783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34784 }
34785 arg1 = reinterpret_cast< wxWindow * >(argp1);
34786 {
34787 PyThreadState* __tstate = wxPyBeginAllowThreads();
34788 result = (wxValidator *)(arg1)->GetValidator();
34789 wxPyEndAllowThreads(__tstate);
34790 if (PyErr_Occurred()) SWIG_fail;
34791 }
34792 {
34793 resultobj = wxPyMake_wxObject(result, (bool)0);
34794 }
34795 return resultobj;
34796 fail:
34797 return NULL;
34798 }
34799
34800
34801 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34802 PyObject *resultobj = 0;
34803 wxWindow *arg1 = (wxWindow *) 0 ;
34804 bool result;
34805 void *argp1 = 0 ;
34806 int res1 = 0 ;
34807 PyObject *swig_obj[1] ;
34808
34809 if (!args) SWIG_fail;
34810 swig_obj[0] = args;
34811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34812 if (!SWIG_IsOK(res1)) {
34813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34814 }
34815 arg1 = reinterpret_cast< wxWindow * >(argp1);
34816 {
34817 PyThreadState* __tstate = wxPyBeginAllowThreads();
34818 result = (bool)(arg1)->Validate();
34819 wxPyEndAllowThreads(__tstate);
34820 if (PyErr_Occurred()) SWIG_fail;
34821 }
34822 {
34823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34824 }
34825 return resultobj;
34826 fail:
34827 return NULL;
34828 }
34829
34830
34831 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34832 PyObject *resultobj = 0;
34833 wxWindow *arg1 = (wxWindow *) 0 ;
34834 bool result;
34835 void *argp1 = 0 ;
34836 int res1 = 0 ;
34837 PyObject *swig_obj[1] ;
34838
34839 if (!args) SWIG_fail;
34840 swig_obj[0] = args;
34841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34842 if (!SWIG_IsOK(res1)) {
34843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34844 }
34845 arg1 = reinterpret_cast< wxWindow * >(argp1);
34846 {
34847 PyThreadState* __tstate = wxPyBeginAllowThreads();
34848 result = (bool)(arg1)->TransferDataToWindow();
34849 wxPyEndAllowThreads(__tstate);
34850 if (PyErr_Occurred()) SWIG_fail;
34851 }
34852 {
34853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34854 }
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34862 PyObject *resultobj = 0;
34863 wxWindow *arg1 = (wxWindow *) 0 ;
34864 bool result;
34865 void *argp1 = 0 ;
34866 int res1 = 0 ;
34867 PyObject *swig_obj[1] ;
34868
34869 if (!args) SWIG_fail;
34870 swig_obj[0] = args;
34871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34874 }
34875 arg1 = reinterpret_cast< wxWindow * >(argp1);
34876 {
34877 PyThreadState* __tstate = wxPyBeginAllowThreads();
34878 result = (bool)(arg1)->TransferDataFromWindow();
34879 wxPyEndAllowThreads(__tstate);
34880 if (PyErr_Occurred()) SWIG_fail;
34881 }
34882 {
34883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34884 }
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34892 PyObject *resultobj = 0;
34893 wxWindow *arg1 = (wxWindow *) 0 ;
34894 void *argp1 = 0 ;
34895 int res1 = 0 ;
34896 PyObject *swig_obj[1] ;
34897
34898 if (!args) SWIG_fail;
34899 swig_obj[0] = args;
34900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34901 if (!SWIG_IsOK(res1)) {
34902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34903 }
34904 arg1 = reinterpret_cast< wxWindow * >(argp1);
34905 {
34906 PyThreadState* __tstate = wxPyBeginAllowThreads();
34907 (arg1)->InitDialog();
34908 wxPyEndAllowThreads(__tstate);
34909 if (PyErr_Occurred()) SWIG_fail;
34910 }
34911 resultobj = SWIG_Py_Void();
34912 return resultobj;
34913 fail:
34914 return NULL;
34915 }
34916
34917
34918 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34919 PyObject *resultobj = 0;
34920 wxWindow *arg1 = (wxWindow *) 0 ;
34921 wxAcceleratorTable *arg2 = 0 ;
34922 void *argp1 = 0 ;
34923 int res1 = 0 ;
34924 void *argp2 = 0 ;
34925 int res2 = 0 ;
34926 PyObject * obj0 = 0 ;
34927 PyObject * obj1 = 0 ;
34928 char * kwnames[] = {
34929 (char *) "self",(char *) "accel", NULL
34930 };
34931
34932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34934 if (!SWIG_IsOK(res1)) {
34935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34936 }
34937 arg1 = reinterpret_cast< wxWindow * >(argp1);
34938 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34939 if (!SWIG_IsOK(res2)) {
34940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34941 }
34942 if (!argp2) {
34943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34944 }
34945 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34946 {
34947 PyThreadState* __tstate = wxPyBeginAllowThreads();
34948 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34949 wxPyEndAllowThreads(__tstate);
34950 if (PyErr_Occurred()) SWIG_fail;
34951 }
34952 resultobj = SWIG_Py_Void();
34953 return resultobj;
34954 fail:
34955 return NULL;
34956 }
34957
34958
34959 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34960 PyObject *resultobj = 0;
34961 wxWindow *arg1 = (wxWindow *) 0 ;
34962 wxAcceleratorTable *result = 0 ;
34963 void *argp1 = 0 ;
34964 int res1 = 0 ;
34965 PyObject *swig_obj[1] ;
34966
34967 if (!args) SWIG_fail;
34968 swig_obj[0] = args;
34969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34970 if (!SWIG_IsOK(res1)) {
34971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34972 }
34973 arg1 = reinterpret_cast< wxWindow * >(argp1);
34974 {
34975 PyThreadState* __tstate = wxPyBeginAllowThreads();
34976 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34977 wxPyEndAllowThreads(__tstate);
34978 if (PyErr_Occurred()) SWIG_fail;
34979 }
34980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34981 return resultobj;
34982 fail:
34983 return NULL;
34984 }
34985
34986
34987 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34988 PyObject *resultobj = 0;
34989 wxWindow *arg1 = (wxWindow *) 0 ;
34990 int arg2 ;
34991 int arg3 ;
34992 int arg4 ;
34993 bool result;
34994 void *argp1 = 0 ;
34995 int res1 = 0 ;
34996 int val2 ;
34997 int ecode2 = 0 ;
34998 int val3 ;
34999 int ecode3 = 0 ;
35000 int val4 ;
35001 int ecode4 = 0 ;
35002 PyObject * obj0 = 0 ;
35003 PyObject * obj1 = 0 ;
35004 PyObject * obj2 = 0 ;
35005 PyObject * obj3 = 0 ;
35006 char * kwnames[] = {
35007 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
35008 };
35009
35010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35012 if (!SWIG_IsOK(res1)) {
35013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35014 }
35015 arg1 = reinterpret_cast< wxWindow * >(argp1);
35016 ecode2 = SWIG_AsVal_int(obj1, &val2);
35017 if (!SWIG_IsOK(ecode2)) {
35018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35019 }
35020 arg2 = static_cast< int >(val2);
35021 ecode3 = SWIG_AsVal_int(obj2, &val3);
35022 if (!SWIG_IsOK(ecode3)) {
35023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35024 }
35025 arg3 = static_cast< int >(val3);
35026 ecode4 = SWIG_AsVal_int(obj3, &val4);
35027 if (!SWIG_IsOK(ecode4)) {
35028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35029 }
35030 arg4 = static_cast< int >(val4);
35031 {
35032 PyThreadState* __tstate = wxPyBeginAllowThreads();
35033 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35034 wxPyEndAllowThreads(__tstate);
35035 if (PyErr_Occurred()) SWIG_fail;
35036 }
35037 {
35038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35039 }
35040 return resultobj;
35041 fail:
35042 return NULL;
35043 }
35044
35045
35046 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35047 PyObject *resultobj = 0;
35048 wxWindow *arg1 = (wxWindow *) 0 ;
35049 int arg2 ;
35050 bool result;
35051 void *argp1 = 0 ;
35052 int res1 = 0 ;
35053 int val2 ;
35054 int ecode2 = 0 ;
35055 PyObject * obj0 = 0 ;
35056 PyObject * obj1 = 0 ;
35057 char * kwnames[] = {
35058 (char *) "self",(char *) "hotkeyId", NULL
35059 };
35060
35061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35063 if (!SWIG_IsOK(res1)) {
35064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35065 }
35066 arg1 = reinterpret_cast< wxWindow * >(argp1);
35067 ecode2 = SWIG_AsVal_int(obj1, &val2);
35068 if (!SWIG_IsOK(ecode2)) {
35069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35070 }
35071 arg2 = static_cast< int >(val2);
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 {
35079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35080 }
35081 return resultobj;
35082 fail:
35083 return NULL;
35084 }
35085
35086
35087 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35088 PyObject *resultobj = 0;
35089 wxWindow *arg1 = (wxWindow *) 0 ;
35090 wxPoint *arg2 = 0 ;
35091 wxPoint result;
35092 void *argp1 = 0 ;
35093 int res1 = 0 ;
35094 wxPoint temp2 ;
35095 PyObject * obj0 = 0 ;
35096 PyObject * obj1 = 0 ;
35097 char * kwnames[] = {
35098 (char *) "self",(char *) "pt", NULL
35099 };
35100
35101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35103 if (!SWIG_IsOK(res1)) {
35104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35105 }
35106 arg1 = reinterpret_cast< wxWindow * >(argp1);
35107 {
35108 arg2 = &temp2;
35109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35110 }
35111 {
35112 PyThreadState* __tstate = wxPyBeginAllowThreads();
35113 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35114 wxPyEndAllowThreads(__tstate);
35115 if (PyErr_Occurred()) SWIG_fail;
35116 }
35117 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35118 return resultobj;
35119 fail:
35120 return NULL;
35121 }
35122
35123
35124 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35125 PyObject *resultobj = 0;
35126 wxWindow *arg1 = (wxWindow *) 0 ;
35127 wxSize *arg2 = 0 ;
35128 wxSize result;
35129 void *argp1 = 0 ;
35130 int res1 = 0 ;
35131 wxSize temp2 ;
35132 PyObject * obj0 = 0 ;
35133 PyObject * obj1 = 0 ;
35134 char * kwnames[] = {
35135 (char *) "self",(char *) "sz", NULL
35136 };
35137
35138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35140 if (!SWIG_IsOK(res1)) {
35141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35142 }
35143 arg1 = reinterpret_cast< wxWindow * >(argp1);
35144 {
35145 arg2 = &temp2;
35146 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35147 }
35148 {
35149 PyThreadState* __tstate = wxPyBeginAllowThreads();
35150 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35151 wxPyEndAllowThreads(__tstate);
35152 if (PyErr_Occurred()) SWIG_fail;
35153 }
35154 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35155 return resultobj;
35156 fail:
35157 return NULL;
35158 }
35159
35160
35161 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35162 PyObject *resultobj = 0;
35163 wxWindow *arg1 = (wxWindow *) 0 ;
35164 wxPoint *arg2 = 0 ;
35165 wxPoint result;
35166 void *argp1 = 0 ;
35167 int res1 = 0 ;
35168 wxPoint temp2 ;
35169 PyObject * obj0 = 0 ;
35170 PyObject * obj1 = 0 ;
35171 char * kwnames[] = {
35172 (char *) "self",(char *) "pt", NULL
35173 };
35174
35175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35177 if (!SWIG_IsOK(res1)) {
35178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35179 }
35180 arg1 = reinterpret_cast< wxWindow * >(argp1);
35181 {
35182 arg2 = &temp2;
35183 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35184 }
35185 {
35186 PyThreadState* __tstate = wxPyBeginAllowThreads();
35187 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35188 wxPyEndAllowThreads(__tstate);
35189 if (PyErr_Occurred()) SWIG_fail;
35190 }
35191 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35192 return resultobj;
35193 fail:
35194 return NULL;
35195 }
35196
35197
35198 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35199 PyObject *resultobj = 0;
35200 wxWindow *arg1 = (wxWindow *) 0 ;
35201 wxSize *arg2 = 0 ;
35202 wxSize result;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 wxSize temp2 ;
35206 PyObject * obj0 = 0 ;
35207 PyObject * obj1 = 0 ;
35208 char * kwnames[] = {
35209 (char *) "self",(char *) "sz", NULL
35210 };
35211
35212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 arg2 = &temp2;
35220 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35221 }
35222 {
35223 PyThreadState* __tstate = wxPyBeginAllowThreads();
35224 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35225 wxPyEndAllowThreads(__tstate);
35226 if (PyErr_Occurred()) SWIG_fail;
35227 }
35228 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35229 return resultobj;
35230 fail:
35231 return NULL;
35232 }
35233
35234
35235 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35236 PyObject *resultobj = 0;
35237 wxWindow *arg1 = (wxWindow *) 0 ;
35238 wxPoint *arg2 = 0 ;
35239 wxPoint result;
35240 void *argp1 = 0 ;
35241 int res1 = 0 ;
35242 wxPoint temp2 ;
35243 PyObject * obj0 = 0 ;
35244 PyObject * obj1 = 0 ;
35245 char * kwnames[] = {
35246 (char *) "self",(char *) "pt", NULL
35247 };
35248
35249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35251 if (!SWIG_IsOK(res1)) {
35252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35253 }
35254 arg1 = reinterpret_cast< wxWindow * >(argp1);
35255 {
35256 arg2 = &temp2;
35257 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35258 }
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35262 wxPyEndAllowThreads(__tstate);
35263 if (PyErr_Occurred()) SWIG_fail;
35264 }
35265 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35266 return resultobj;
35267 fail:
35268 return NULL;
35269 }
35270
35271
35272 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35273 PyObject *resultobj = 0;
35274 wxWindow *arg1 = (wxWindow *) 0 ;
35275 wxSize *arg2 = 0 ;
35276 wxSize result;
35277 void *argp1 = 0 ;
35278 int res1 = 0 ;
35279 wxSize temp2 ;
35280 PyObject * obj0 = 0 ;
35281 PyObject * obj1 = 0 ;
35282 char * kwnames[] = {
35283 (char *) "self",(char *) "sz", NULL
35284 };
35285
35286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35288 if (!SWIG_IsOK(res1)) {
35289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35290 }
35291 arg1 = reinterpret_cast< wxWindow * >(argp1);
35292 {
35293 arg2 = &temp2;
35294 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35295 }
35296 {
35297 PyThreadState* __tstate = wxPyBeginAllowThreads();
35298 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35299 wxPyEndAllowThreads(__tstate);
35300 if (PyErr_Occurred()) SWIG_fail;
35301 }
35302 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35303 return resultobj;
35304 fail:
35305 return NULL;
35306 }
35307
35308
35309 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35310 PyObject *resultobj = 0;
35311 wxWindow *arg1 = (wxWindow *) 0 ;
35312 int arg2 ;
35313 int arg3 ;
35314 void *argp1 = 0 ;
35315 int res1 = 0 ;
35316 int val2 ;
35317 int ecode2 = 0 ;
35318 int val3 ;
35319 int ecode3 = 0 ;
35320 PyObject * obj0 = 0 ;
35321 PyObject * obj1 = 0 ;
35322 PyObject * obj2 = 0 ;
35323 char * kwnames[] = {
35324 (char *) "self",(char *) "x",(char *) "y", NULL
35325 };
35326
35327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35329 if (!SWIG_IsOK(res1)) {
35330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35331 }
35332 arg1 = reinterpret_cast< wxWindow * >(argp1);
35333 ecode2 = SWIG_AsVal_int(obj1, &val2);
35334 if (!SWIG_IsOK(ecode2)) {
35335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35336 }
35337 arg2 = static_cast< int >(val2);
35338 ecode3 = SWIG_AsVal_int(obj2, &val3);
35339 if (!SWIG_IsOK(ecode3)) {
35340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35341 }
35342 arg3 = static_cast< int >(val3);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 (arg1)->WarpPointer(arg2,arg3);
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 resultobj = SWIG_Py_Void();
35350 return resultobj;
35351 fail:
35352 return NULL;
35353 }
35354
35355
35356 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35357 PyObject *resultobj = 0;
35358 wxWindow *arg1 = (wxWindow *) 0 ;
35359 void *argp1 = 0 ;
35360 int res1 = 0 ;
35361 PyObject *swig_obj[1] ;
35362
35363 if (!args) SWIG_fail;
35364 swig_obj[0] = args;
35365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35366 if (!SWIG_IsOK(res1)) {
35367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35368 }
35369 arg1 = reinterpret_cast< wxWindow * >(argp1);
35370 {
35371 PyThreadState* __tstate = wxPyBeginAllowThreads();
35372 (arg1)->CaptureMouse();
35373 wxPyEndAllowThreads(__tstate);
35374 if (PyErr_Occurred()) SWIG_fail;
35375 }
35376 resultobj = SWIG_Py_Void();
35377 return resultobj;
35378 fail:
35379 return NULL;
35380 }
35381
35382
35383 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35384 PyObject *resultobj = 0;
35385 wxWindow *arg1 = (wxWindow *) 0 ;
35386 void *argp1 = 0 ;
35387 int res1 = 0 ;
35388 PyObject *swig_obj[1] ;
35389
35390 if (!args) SWIG_fail;
35391 swig_obj[0] = args;
35392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35393 if (!SWIG_IsOK(res1)) {
35394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35395 }
35396 arg1 = reinterpret_cast< wxWindow * >(argp1);
35397 {
35398 PyThreadState* __tstate = wxPyBeginAllowThreads();
35399 (arg1)->ReleaseMouse();
35400 wxPyEndAllowThreads(__tstate);
35401 if (PyErr_Occurred()) SWIG_fail;
35402 }
35403 resultobj = SWIG_Py_Void();
35404 return resultobj;
35405 fail:
35406 return NULL;
35407 }
35408
35409
35410 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35411 PyObject *resultobj = 0;
35412 wxWindow *result = 0 ;
35413
35414 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35415 {
35416 if (!wxPyCheckForApp()) SWIG_fail;
35417 PyThreadState* __tstate = wxPyBeginAllowThreads();
35418 result = (wxWindow *)wxWindow::GetCapture();
35419 wxPyEndAllowThreads(__tstate);
35420 if (PyErr_Occurred()) SWIG_fail;
35421 }
35422 {
35423 resultobj = wxPyMake_wxObject(result, 0);
35424 }
35425 return resultobj;
35426 fail:
35427 return NULL;
35428 }
35429
35430
35431 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35432 PyObject *resultobj = 0;
35433 wxWindow *arg1 = (wxWindow *) 0 ;
35434 bool result;
35435 void *argp1 = 0 ;
35436 int res1 = 0 ;
35437 PyObject *swig_obj[1] ;
35438
35439 if (!args) SWIG_fail;
35440 swig_obj[0] = args;
35441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35442 if (!SWIG_IsOK(res1)) {
35443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35444 }
35445 arg1 = reinterpret_cast< wxWindow * >(argp1);
35446 {
35447 PyThreadState* __tstate = wxPyBeginAllowThreads();
35448 result = (bool)((wxWindow const *)arg1)->HasCapture();
35449 wxPyEndAllowThreads(__tstate);
35450 if (PyErr_Occurred()) SWIG_fail;
35451 }
35452 {
35453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35454 }
35455 return resultobj;
35456 fail:
35457 return NULL;
35458 }
35459
35460
35461 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35462 PyObject *resultobj = 0;
35463 wxWindow *arg1 = (wxWindow *) 0 ;
35464 bool arg2 = (bool) true ;
35465 wxRect *arg3 = (wxRect *) NULL ;
35466 void *argp1 = 0 ;
35467 int res1 = 0 ;
35468 bool val2 ;
35469 int ecode2 = 0 ;
35470 void *argp3 = 0 ;
35471 int res3 = 0 ;
35472 PyObject * obj0 = 0 ;
35473 PyObject * obj1 = 0 ;
35474 PyObject * obj2 = 0 ;
35475 char * kwnames[] = {
35476 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35477 };
35478
35479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35481 if (!SWIG_IsOK(res1)) {
35482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35483 }
35484 arg1 = reinterpret_cast< wxWindow * >(argp1);
35485 if (obj1) {
35486 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35487 if (!SWIG_IsOK(ecode2)) {
35488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35489 }
35490 arg2 = static_cast< bool >(val2);
35491 }
35492 if (obj2) {
35493 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35494 if (!SWIG_IsOK(res3)) {
35495 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35496 }
35497 arg3 = reinterpret_cast< wxRect * >(argp3);
35498 }
35499 {
35500 PyThreadState* __tstate = wxPyBeginAllowThreads();
35501 (arg1)->Refresh(arg2,(wxRect const *)arg3);
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_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35513 PyObject *resultobj = 0;
35514 wxWindow *arg1 = (wxWindow *) 0 ;
35515 wxRect *arg2 = 0 ;
35516 bool arg3 = (bool) true ;
35517 void *argp1 = 0 ;
35518 int res1 = 0 ;
35519 wxRect temp2 ;
35520 bool val3 ;
35521 int ecode3 = 0 ;
35522 PyObject * obj0 = 0 ;
35523 PyObject * obj1 = 0 ;
35524 PyObject * obj2 = 0 ;
35525 char * kwnames[] = {
35526 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35527 };
35528
35529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35531 if (!SWIG_IsOK(res1)) {
35532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35533 }
35534 arg1 = reinterpret_cast< wxWindow * >(argp1);
35535 {
35536 arg2 = &temp2;
35537 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35538 }
35539 if (obj2) {
35540 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35541 if (!SWIG_IsOK(ecode3)) {
35542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35543 }
35544 arg3 = static_cast< bool >(val3);
35545 }
35546 {
35547 PyThreadState* __tstate = wxPyBeginAllowThreads();
35548 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35549 wxPyEndAllowThreads(__tstate);
35550 if (PyErr_Occurred()) SWIG_fail;
35551 }
35552 resultobj = SWIG_Py_Void();
35553 return resultobj;
35554 fail:
35555 return NULL;
35556 }
35557
35558
35559 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35560 PyObject *resultobj = 0;
35561 wxWindow *arg1 = (wxWindow *) 0 ;
35562 void *argp1 = 0 ;
35563 int res1 = 0 ;
35564 PyObject *swig_obj[1] ;
35565
35566 if (!args) SWIG_fail;
35567 swig_obj[0] = args;
35568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35569 if (!SWIG_IsOK(res1)) {
35570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35571 }
35572 arg1 = reinterpret_cast< wxWindow * >(argp1);
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 (arg1)->Update();
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 resultobj = SWIG_Py_Void();
35580 return resultobj;
35581 fail:
35582 return NULL;
35583 }
35584
35585
35586 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35587 PyObject *resultobj = 0;
35588 wxWindow *arg1 = (wxWindow *) 0 ;
35589 void *argp1 = 0 ;
35590 int res1 = 0 ;
35591 PyObject *swig_obj[1] ;
35592
35593 if (!args) SWIG_fail;
35594 swig_obj[0] = args;
35595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35596 if (!SWIG_IsOK(res1)) {
35597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35598 }
35599 arg1 = reinterpret_cast< wxWindow * >(argp1);
35600 {
35601 PyThreadState* __tstate = wxPyBeginAllowThreads();
35602 (arg1)->ClearBackground();
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 resultobj = SWIG_Py_Void();
35607 return resultobj;
35608 fail:
35609 return NULL;
35610 }
35611
35612
35613 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35614 PyObject *resultobj = 0;
35615 wxWindow *arg1 = (wxWindow *) 0 ;
35616 void *argp1 = 0 ;
35617 int res1 = 0 ;
35618 PyObject *swig_obj[1] ;
35619
35620 if (!args) SWIG_fail;
35621 swig_obj[0] = args;
35622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35623 if (!SWIG_IsOK(res1)) {
35624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35625 }
35626 arg1 = reinterpret_cast< wxWindow * >(argp1);
35627 {
35628 PyThreadState* __tstate = wxPyBeginAllowThreads();
35629 (arg1)->Freeze();
35630 wxPyEndAllowThreads(__tstate);
35631 if (PyErr_Occurred()) SWIG_fail;
35632 }
35633 resultobj = SWIG_Py_Void();
35634 return resultobj;
35635 fail:
35636 return NULL;
35637 }
35638
35639
35640 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35641 PyObject *resultobj = 0;
35642 wxWindow *arg1 = (wxWindow *) 0 ;
35643 bool result;
35644 void *argp1 = 0 ;
35645 int res1 = 0 ;
35646 PyObject *swig_obj[1] ;
35647
35648 if (!args) SWIG_fail;
35649 swig_obj[0] = args;
35650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35651 if (!SWIG_IsOK(res1)) {
35652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35653 }
35654 arg1 = reinterpret_cast< wxWindow * >(argp1);
35655 {
35656 PyThreadState* __tstate = wxPyBeginAllowThreads();
35657 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35658 wxPyEndAllowThreads(__tstate);
35659 if (PyErr_Occurred()) SWIG_fail;
35660 }
35661 {
35662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35663 }
35664 return resultobj;
35665 fail:
35666 return NULL;
35667 }
35668
35669
35670 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35671 PyObject *resultobj = 0;
35672 wxWindow *arg1 = (wxWindow *) 0 ;
35673 void *argp1 = 0 ;
35674 int res1 = 0 ;
35675 PyObject *swig_obj[1] ;
35676
35677 if (!args) SWIG_fail;
35678 swig_obj[0] = args;
35679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35680 if (!SWIG_IsOK(res1)) {
35681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35682 }
35683 arg1 = reinterpret_cast< wxWindow * >(argp1);
35684 {
35685 PyThreadState* __tstate = wxPyBeginAllowThreads();
35686 (arg1)->Thaw();
35687 wxPyEndAllowThreads(__tstate);
35688 if (PyErr_Occurred()) SWIG_fail;
35689 }
35690 resultobj = SWIG_Py_Void();
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35698 PyObject *resultobj = 0;
35699 wxWindow *arg1 = (wxWindow *) 0 ;
35700 wxDC *arg2 = 0 ;
35701 void *argp1 = 0 ;
35702 int res1 = 0 ;
35703 void *argp2 = 0 ;
35704 int res2 = 0 ;
35705 PyObject * obj0 = 0 ;
35706 PyObject * obj1 = 0 ;
35707 char * kwnames[] = {
35708 (char *) "self",(char *) "dc", NULL
35709 };
35710
35711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35713 if (!SWIG_IsOK(res1)) {
35714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35715 }
35716 arg1 = reinterpret_cast< wxWindow * >(argp1);
35717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35718 if (!SWIG_IsOK(res2)) {
35719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35720 }
35721 if (!argp2) {
35722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35723 }
35724 arg2 = reinterpret_cast< wxDC * >(argp2);
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 (arg1)->PrepareDC(*arg2);
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 resultobj = SWIG_Py_Void();
35732 return resultobj;
35733 fail:
35734 return NULL;
35735 }
35736
35737
35738 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35739 PyObject *resultobj = 0;
35740 wxWindow *arg1 = (wxWindow *) 0 ;
35741 bool result;
35742 void *argp1 = 0 ;
35743 int res1 = 0 ;
35744 PyObject *swig_obj[1] ;
35745
35746 if (!args) SWIG_fail;
35747 swig_obj[0] = args;
35748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35749 if (!SWIG_IsOK(res1)) {
35750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35751 }
35752 arg1 = reinterpret_cast< wxWindow * >(argp1);
35753 {
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35756 wxPyEndAllowThreads(__tstate);
35757 if (PyErr_Occurred()) SWIG_fail;
35758 }
35759 {
35760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35761 }
35762 return resultobj;
35763 fail:
35764 return NULL;
35765 }
35766
35767
35768 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35769 PyObject *resultobj = 0;
35770 wxWindow *arg1 = (wxWindow *) 0 ;
35771 wxRegion *result = 0 ;
35772 void *argp1 = 0 ;
35773 int res1 = 0 ;
35774 PyObject *swig_obj[1] ;
35775
35776 if (!args) SWIG_fail;
35777 swig_obj[0] = args;
35778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35779 if (!SWIG_IsOK(res1)) {
35780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35781 }
35782 arg1 = reinterpret_cast< wxWindow * >(argp1);
35783 {
35784 PyThreadState* __tstate = wxPyBeginAllowThreads();
35785 {
35786 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35787 result = (wxRegion *) &_result_ref;
35788 }
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35793 return resultobj;
35794 fail:
35795 return NULL;
35796 }
35797
35798
35799 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35800 PyObject *resultobj = 0;
35801 wxWindow *arg1 = (wxWindow *) 0 ;
35802 wxRect result;
35803 void *argp1 = 0 ;
35804 int res1 = 0 ;
35805 PyObject *swig_obj[1] ;
35806
35807 if (!args) SWIG_fail;
35808 swig_obj[0] = args;
35809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35810 if (!SWIG_IsOK(res1)) {
35811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35812 }
35813 arg1 = reinterpret_cast< wxWindow * >(argp1);
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35817 wxPyEndAllowThreads(__tstate);
35818 if (PyErr_Occurred()) SWIG_fail;
35819 }
35820 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35821 return resultobj;
35822 fail:
35823 return NULL;
35824 }
35825
35826
35827 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35828 PyObject *resultobj = 0;
35829 wxWindow *arg1 = (wxWindow *) 0 ;
35830 int arg2 ;
35831 int arg3 ;
35832 int arg4 = (int) 1 ;
35833 int arg5 = (int) 1 ;
35834 bool result;
35835 void *argp1 = 0 ;
35836 int res1 = 0 ;
35837 int val2 ;
35838 int ecode2 = 0 ;
35839 int val3 ;
35840 int ecode3 = 0 ;
35841 int val4 ;
35842 int ecode4 = 0 ;
35843 int val5 ;
35844 int ecode5 = 0 ;
35845 PyObject * obj0 = 0 ;
35846 PyObject * obj1 = 0 ;
35847 PyObject * obj2 = 0 ;
35848 PyObject * obj3 = 0 ;
35849 PyObject * obj4 = 0 ;
35850 char * kwnames[] = {
35851 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35852 };
35853
35854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35856 if (!SWIG_IsOK(res1)) {
35857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35858 }
35859 arg1 = reinterpret_cast< wxWindow * >(argp1);
35860 ecode2 = SWIG_AsVal_int(obj1, &val2);
35861 if (!SWIG_IsOK(ecode2)) {
35862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35863 }
35864 arg2 = static_cast< int >(val2);
35865 ecode3 = SWIG_AsVal_int(obj2, &val3);
35866 if (!SWIG_IsOK(ecode3)) {
35867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35868 }
35869 arg3 = static_cast< int >(val3);
35870 if (obj3) {
35871 ecode4 = SWIG_AsVal_int(obj3, &val4);
35872 if (!SWIG_IsOK(ecode4)) {
35873 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35874 }
35875 arg4 = static_cast< int >(val4);
35876 }
35877 if (obj4) {
35878 ecode5 = SWIG_AsVal_int(obj4, &val5);
35879 if (!SWIG_IsOK(ecode5)) {
35880 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35881 }
35882 arg5 = static_cast< int >(val5);
35883 }
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 {
35891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35892 }
35893 return resultobj;
35894 fail:
35895 return NULL;
35896 }
35897
35898
35899 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35900 PyObject *resultobj = 0;
35901 wxWindow *arg1 = (wxWindow *) 0 ;
35902 wxPoint *arg2 = 0 ;
35903 bool result;
35904 void *argp1 = 0 ;
35905 int res1 = 0 ;
35906 wxPoint temp2 ;
35907 PyObject * obj0 = 0 ;
35908 PyObject * obj1 = 0 ;
35909 char * kwnames[] = {
35910 (char *) "self",(char *) "pt", NULL
35911 };
35912
35913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35915 if (!SWIG_IsOK(res1)) {
35916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35917 }
35918 arg1 = reinterpret_cast< wxWindow * >(argp1);
35919 {
35920 arg2 = &temp2;
35921 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35922 }
35923 {
35924 PyThreadState* __tstate = wxPyBeginAllowThreads();
35925 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35926 wxPyEndAllowThreads(__tstate);
35927 if (PyErr_Occurred()) SWIG_fail;
35928 }
35929 {
35930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35931 }
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj = 0;
35940 wxWindow *arg1 = (wxWindow *) 0 ;
35941 wxRect *arg2 = 0 ;
35942 bool result;
35943 void *argp1 = 0 ;
35944 int res1 = 0 ;
35945 wxRect temp2 ;
35946 PyObject * obj0 = 0 ;
35947 PyObject * obj1 = 0 ;
35948 char * kwnames[] = {
35949 (char *) "self",(char *) "rect", NULL
35950 };
35951
35952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35954 if (!SWIG_IsOK(res1)) {
35955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35956 }
35957 arg1 = reinterpret_cast< wxWindow * >(argp1);
35958 {
35959 arg2 = &temp2;
35960 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35961 }
35962 {
35963 PyThreadState* __tstate = wxPyBeginAllowThreads();
35964 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 {
35969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35970 }
35971 return resultobj;
35972 fail:
35973 return NULL;
35974 }
35975
35976
35977 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35978 PyObject *resultobj = 0;
35979 wxWindow *arg1 = (wxWindow *) 0 ;
35980 SwigValueWrapper<wxVisualAttributes > result;
35981 void *argp1 = 0 ;
35982 int res1 = 0 ;
35983 PyObject *swig_obj[1] ;
35984
35985 if (!args) SWIG_fail;
35986 swig_obj[0] = args;
35987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35988 if (!SWIG_IsOK(res1)) {
35989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35990 }
35991 arg1 = reinterpret_cast< wxWindow * >(argp1);
35992 {
35993 PyThreadState* __tstate = wxPyBeginAllowThreads();
35994 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35995 wxPyEndAllowThreads(__tstate);
35996 if (PyErr_Occurred()) SWIG_fail;
35997 }
35998 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35999 return resultobj;
36000 fail:
36001 return NULL;
36002 }
36003
36004
36005 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36006 PyObject *resultobj = 0;
36007 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36008 SwigValueWrapper<wxVisualAttributes > result;
36009 int val1 ;
36010 int ecode1 = 0 ;
36011 PyObject * obj0 = 0 ;
36012 char * kwnames[] = {
36013 (char *) "variant", NULL
36014 };
36015
36016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36017 if (obj0) {
36018 ecode1 = SWIG_AsVal_int(obj0, &val1);
36019 if (!SWIG_IsOK(ecode1)) {
36020 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36021 }
36022 arg1 = static_cast< wxWindowVariant >(val1);
36023 }
36024 {
36025 if (!wxPyCheckForApp()) SWIG_fail;
36026 PyThreadState* __tstate = wxPyBeginAllowThreads();
36027 result = wxWindow::GetClassDefaultAttributes(arg1);
36028 wxPyEndAllowThreads(__tstate);
36029 if (PyErr_Occurred()) SWIG_fail;
36030 }
36031 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36039 PyObject *resultobj = 0;
36040 wxWindow *arg1 = (wxWindow *) 0 ;
36041 wxColour *arg2 = 0 ;
36042 bool result;
36043 void *argp1 = 0 ;
36044 int res1 = 0 ;
36045 wxColour temp2 ;
36046 PyObject * obj0 = 0 ;
36047 PyObject * obj1 = 0 ;
36048 char * kwnames[] = {
36049 (char *) "self",(char *) "colour", NULL
36050 };
36051
36052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) 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_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36056 }
36057 arg1 = reinterpret_cast< wxWindow * >(argp1);
36058 {
36059 arg2 = &temp2;
36060 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36061 }
36062 {
36063 PyThreadState* __tstate = wxPyBeginAllowThreads();
36064 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36065 wxPyEndAllowThreads(__tstate);
36066 if (PyErr_Occurred()) SWIG_fail;
36067 }
36068 {
36069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36070 }
36071 return resultobj;
36072 fail:
36073 return NULL;
36074 }
36075
36076
36077 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36078 PyObject *resultobj = 0;
36079 wxWindow *arg1 = (wxWindow *) 0 ;
36080 wxColour *arg2 = 0 ;
36081 void *argp1 = 0 ;
36082 int res1 = 0 ;
36083 wxColour temp2 ;
36084 PyObject * obj0 = 0 ;
36085 PyObject * obj1 = 0 ;
36086 char * kwnames[] = {
36087 (char *) "self",(char *) "colour", NULL
36088 };
36089
36090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36092 if (!SWIG_IsOK(res1)) {
36093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36094 }
36095 arg1 = reinterpret_cast< wxWindow * >(argp1);
36096 {
36097 arg2 = &temp2;
36098 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36099 }
36100 {
36101 PyThreadState* __tstate = wxPyBeginAllowThreads();
36102 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36103 wxPyEndAllowThreads(__tstate);
36104 if (PyErr_Occurred()) SWIG_fail;
36105 }
36106 resultobj = SWIG_Py_Void();
36107 return resultobj;
36108 fail:
36109 return NULL;
36110 }
36111
36112
36113 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36114 PyObject *resultobj = 0;
36115 wxWindow *arg1 = (wxWindow *) 0 ;
36116 wxColour *arg2 = 0 ;
36117 bool result;
36118 void *argp1 = 0 ;
36119 int res1 = 0 ;
36120 wxColour temp2 ;
36121 PyObject * obj0 = 0 ;
36122 PyObject * obj1 = 0 ;
36123 char * kwnames[] = {
36124 (char *) "self",(char *) "colour", NULL
36125 };
36126
36127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36129 if (!SWIG_IsOK(res1)) {
36130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36131 }
36132 arg1 = reinterpret_cast< wxWindow * >(argp1);
36133 {
36134 arg2 = &temp2;
36135 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36136 }
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36140 wxPyEndAllowThreads(__tstate);
36141 if (PyErr_Occurred()) SWIG_fail;
36142 }
36143 {
36144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36145 }
36146 return resultobj;
36147 fail:
36148 return NULL;
36149 }
36150
36151
36152 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36153 PyObject *resultobj = 0;
36154 wxWindow *arg1 = (wxWindow *) 0 ;
36155 wxColour *arg2 = 0 ;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158 wxColour temp2 ;
36159 PyObject * obj0 = 0 ;
36160 PyObject * obj1 = 0 ;
36161 char * kwnames[] = {
36162 (char *) "self",(char *) "colour", NULL
36163 };
36164
36165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36167 if (!SWIG_IsOK(res1)) {
36168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36169 }
36170 arg1 = reinterpret_cast< wxWindow * >(argp1);
36171 {
36172 arg2 = &temp2;
36173 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36174 }
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 resultobj = SWIG_Py_Void();
36182 return resultobj;
36183 fail:
36184 return NULL;
36185 }
36186
36187
36188 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36189 PyObject *resultobj = 0;
36190 wxWindow *arg1 = (wxWindow *) 0 ;
36191 wxColour result;
36192 void *argp1 = 0 ;
36193 int res1 = 0 ;
36194 PyObject *swig_obj[1] ;
36195
36196 if (!args) SWIG_fail;
36197 swig_obj[0] = args;
36198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 {
36204 PyThreadState* __tstate = wxPyBeginAllowThreads();
36205 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36206 wxPyEndAllowThreads(__tstate);
36207 if (PyErr_Occurred()) SWIG_fail;
36208 }
36209 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36210 return resultobj;
36211 fail:
36212 return NULL;
36213 }
36214
36215
36216 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36217 PyObject *resultobj = 0;
36218 wxWindow *arg1 = (wxWindow *) 0 ;
36219 wxColour result;
36220 void *argp1 = 0 ;
36221 int res1 = 0 ;
36222 PyObject *swig_obj[1] ;
36223
36224 if (!args) SWIG_fail;
36225 swig_obj[0] = args;
36226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36227 if (!SWIG_IsOK(res1)) {
36228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36229 }
36230 arg1 = reinterpret_cast< wxWindow * >(argp1);
36231 {
36232 PyThreadState* __tstate = wxPyBeginAllowThreads();
36233 result = ((wxWindow const *)arg1)->GetForegroundColour();
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36238 return resultobj;
36239 fail:
36240 return NULL;
36241 }
36242
36243
36244 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36245 PyObject *resultobj = 0;
36246 wxWindow *arg1 = (wxWindow *) 0 ;
36247 bool result;
36248 void *argp1 = 0 ;
36249 int res1 = 0 ;
36250 PyObject *swig_obj[1] ;
36251
36252 if (!args) SWIG_fail;
36253 swig_obj[0] = args;
36254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36255 if (!SWIG_IsOK(res1)) {
36256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36257 }
36258 arg1 = reinterpret_cast< wxWindow * >(argp1);
36259 {
36260 PyThreadState* __tstate = wxPyBeginAllowThreads();
36261 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36262 wxPyEndAllowThreads(__tstate);
36263 if (PyErr_Occurred()) SWIG_fail;
36264 }
36265 {
36266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36267 }
36268 return resultobj;
36269 fail:
36270 return NULL;
36271 }
36272
36273
36274 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36275 PyObject *resultobj = 0;
36276 wxWindow *arg1 = (wxWindow *) 0 ;
36277 bool result;
36278 void *argp1 = 0 ;
36279 int res1 = 0 ;
36280 PyObject *swig_obj[1] ;
36281
36282 if (!args) SWIG_fail;
36283 swig_obj[0] = args;
36284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36285 if (!SWIG_IsOK(res1)) {
36286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36287 }
36288 arg1 = reinterpret_cast< wxWindow * >(argp1);
36289 {
36290 PyThreadState* __tstate = wxPyBeginAllowThreads();
36291 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36292 wxPyEndAllowThreads(__tstate);
36293 if (PyErr_Occurred()) SWIG_fail;
36294 }
36295 {
36296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36297 }
36298 return resultobj;
36299 fail:
36300 return NULL;
36301 }
36302
36303
36304 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36305 PyObject *resultobj = 0;
36306 wxWindow *arg1 = (wxWindow *) 0 ;
36307 wxBackgroundStyle arg2 ;
36308 bool result;
36309 void *argp1 = 0 ;
36310 int res1 = 0 ;
36311 int val2 ;
36312 int ecode2 = 0 ;
36313 PyObject * obj0 = 0 ;
36314 PyObject * obj1 = 0 ;
36315 char * kwnames[] = {
36316 (char *) "self",(char *) "style", NULL
36317 };
36318
36319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) 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_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36323 }
36324 arg1 = reinterpret_cast< wxWindow * >(argp1);
36325 ecode2 = SWIG_AsVal_int(obj1, &val2);
36326 if (!SWIG_IsOK(ecode2)) {
36327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36328 }
36329 arg2 = static_cast< wxBackgroundStyle >(val2);
36330 {
36331 PyThreadState* __tstate = wxPyBeginAllowThreads();
36332 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36333 wxPyEndAllowThreads(__tstate);
36334 if (PyErr_Occurred()) SWIG_fail;
36335 }
36336 {
36337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36338 }
36339 return resultobj;
36340 fail:
36341 return NULL;
36342 }
36343
36344
36345 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36346 PyObject *resultobj = 0;
36347 wxWindow *arg1 = (wxWindow *) 0 ;
36348 wxBackgroundStyle result;
36349 void *argp1 = 0 ;
36350 int res1 = 0 ;
36351 PyObject *swig_obj[1] ;
36352
36353 if (!args) SWIG_fail;
36354 swig_obj[0] = args;
36355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36356 if (!SWIG_IsOK(res1)) {
36357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36358 }
36359 arg1 = reinterpret_cast< wxWindow * >(argp1);
36360 {
36361 PyThreadState* __tstate = wxPyBeginAllowThreads();
36362 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 resultobj = SWIG_From_int(static_cast< int >(result));
36367 return resultobj;
36368 fail:
36369 return NULL;
36370 }
36371
36372
36373 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36374 PyObject *resultobj = 0;
36375 wxWindow *arg1 = (wxWindow *) 0 ;
36376 bool result;
36377 void *argp1 = 0 ;
36378 int res1 = 0 ;
36379 PyObject *swig_obj[1] ;
36380
36381 if (!args) SWIG_fail;
36382 swig_obj[0] = args;
36383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36384 if (!SWIG_IsOK(res1)) {
36385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36386 }
36387 arg1 = reinterpret_cast< wxWindow * >(argp1);
36388 {
36389 PyThreadState* __tstate = wxPyBeginAllowThreads();
36390 result = (bool)(arg1)->HasTransparentBackground();
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 {
36395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36396 }
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj = 0;
36405 wxWindow *arg1 = (wxWindow *) 0 ;
36406 wxCursor *arg2 = 0 ;
36407 bool result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 void *argp2 = 0 ;
36411 int res2 = 0 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "cursor", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36425 if (!SWIG_IsOK(res2)) {
36426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36427 }
36428 if (!argp2) {
36429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36430 }
36431 arg2 = reinterpret_cast< wxCursor * >(argp2);
36432 {
36433 PyThreadState* __tstate = wxPyBeginAllowThreads();
36434 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36435 wxPyEndAllowThreads(__tstate);
36436 if (PyErr_Occurred()) SWIG_fail;
36437 }
36438 {
36439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36440 }
36441 return resultobj;
36442 fail:
36443 return NULL;
36444 }
36445
36446
36447 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36448 PyObject *resultobj = 0;
36449 wxWindow *arg1 = (wxWindow *) 0 ;
36450 wxCursor result;
36451 void *argp1 = 0 ;
36452 int res1 = 0 ;
36453 PyObject *swig_obj[1] ;
36454
36455 if (!args) SWIG_fail;
36456 swig_obj[0] = args;
36457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36458 if (!SWIG_IsOK(res1)) {
36459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36460 }
36461 arg1 = reinterpret_cast< wxWindow * >(argp1);
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 result = (arg1)->GetCursor();
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj = 0;
36477 wxWindow *arg1 = (wxWindow *) 0 ;
36478 wxFont *arg2 = 0 ;
36479 bool result;
36480 void *argp1 = 0 ;
36481 int res1 = 0 ;
36482 void *argp2 = 0 ;
36483 int res2 = 0 ;
36484 PyObject * obj0 = 0 ;
36485 PyObject * obj1 = 0 ;
36486 char * kwnames[] = {
36487 (char *) "self",(char *) "font", NULL
36488 };
36489
36490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36492 if (!SWIG_IsOK(res1)) {
36493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36494 }
36495 arg1 = reinterpret_cast< wxWindow * >(argp1);
36496 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36497 if (!SWIG_IsOK(res2)) {
36498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36499 }
36500 if (!argp2) {
36501 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36502 }
36503 arg2 = reinterpret_cast< wxFont * >(argp2);
36504 {
36505 PyThreadState* __tstate = wxPyBeginAllowThreads();
36506 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 {
36511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36512 }
36513 return resultobj;
36514 fail:
36515 return NULL;
36516 }
36517
36518
36519 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36520 PyObject *resultobj = 0;
36521 wxWindow *arg1 = (wxWindow *) 0 ;
36522 wxFont *arg2 = 0 ;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 void *argp2 = 0 ;
36526 int res2 = 0 ;
36527 PyObject * obj0 = 0 ;
36528 PyObject * obj1 = 0 ;
36529 char * kwnames[] = {
36530 (char *) "self",(char *) "font", NULL
36531 };
36532
36533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36540 if (!SWIG_IsOK(res2)) {
36541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36542 }
36543 if (!argp2) {
36544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36545 }
36546 arg2 = reinterpret_cast< wxFont * >(argp2);
36547 {
36548 PyThreadState* __tstate = wxPyBeginAllowThreads();
36549 (arg1)->SetOwnFont((wxFont const &)*arg2);
36550 wxPyEndAllowThreads(__tstate);
36551 if (PyErr_Occurred()) SWIG_fail;
36552 }
36553 resultobj = SWIG_Py_Void();
36554 return resultobj;
36555 fail:
36556 return NULL;
36557 }
36558
36559
36560 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36561 PyObject *resultobj = 0;
36562 wxWindow *arg1 = (wxWindow *) 0 ;
36563 wxFont result;
36564 void *argp1 = 0 ;
36565 int res1 = 0 ;
36566 PyObject *swig_obj[1] ;
36567
36568 if (!args) SWIG_fail;
36569 swig_obj[0] = args;
36570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36571 if (!SWIG_IsOK(res1)) {
36572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36573 }
36574 arg1 = reinterpret_cast< wxWindow * >(argp1);
36575 {
36576 PyThreadState* __tstate = wxPyBeginAllowThreads();
36577 result = (arg1)->GetFont();
36578 wxPyEndAllowThreads(__tstate);
36579 if (PyErr_Occurred()) SWIG_fail;
36580 }
36581 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36582 return resultobj;
36583 fail:
36584 return NULL;
36585 }
36586
36587
36588 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36589 PyObject *resultobj = 0;
36590 wxWindow *arg1 = (wxWindow *) 0 ;
36591 wxCaret *arg2 = (wxCaret *) 0 ;
36592 void *argp1 = 0 ;
36593 int res1 = 0 ;
36594 int res2 = 0 ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 char * kwnames[] = {
36598 (char *) "self",(char *) "caret", NULL
36599 };
36600
36601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36603 if (!SWIG_IsOK(res1)) {
36604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36605 }
36606 arg1 = reinterpret_cast< wxWindow * >(argp1);
36607 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36608 if (!SWIG_IsOK(res2)) {
36609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36610 }
36611 {
36612 PyThreadState* __tstate = wxPyBeginAllowThreads();
36613 (arg1)->SetCaret(arg2);
36614 wxPyEndAllowThreads(__tstate);
36615 if (PyErr_Occurred()) SWIG_fail;
36616 }
36617 resultobj = SWIG_Py_Void();
36618 return resultobj;
36619 fail:
36620 return NULL;
36621 }
36622
36623
36624 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36625 PyObject *resultobj = 0;
36626 wxWindow *arg1 = (wxWindow *) 0 ;
36627 wxCaret *result = 0 ;
36628 void *argp1 = 0 ;
36629 int res1 = 0 ;
36630 PyObject *swig_obj[1] ;
36631
36632 if (!args) SWIG_fail;
36633 swig_obj[0] = args;
36634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36635 if (!SWIG_IsOK(res1)) {
36636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36637 }
36638 arg1 = reinterpret_cast< wxWindow * >(argp1);
36639 {
36640 PyThreadState* __tstate = wxPyBeginAllowThreads();
36641 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36642 wxPyEndAllowThreads(__tstate);
36643 if (PyErr_Occurred()) SWIG_fail;
36644 }
36645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36646 return resultobj;
36647 fail:
36648 return NULL;
36649 }
36650
36651
36652 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36653 PyObject *resultobj = 0;
36654 wxWindow *arg1 = (wxWindow *) 0 ;
36655 int result;
36656 void *argp1 = 0 ;
36657 int res1 = 0 ;
36658 PyObject *swig_obj[1] ;
36659
36660 if (!args) SWIG_fail;
36661 swig_obj[0] = args;
36662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36663 if (!SWIG_IsOK(res1)) {
36664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36665 }
36666 arg1 = reinterpret_cast< wxWindow * >(argp1);
36667 {
36668 PyThreadState* __tstate = wxPyBeginAllowThreads();
36669 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36670 wxPyEndAllowThreads(__tstate);
36671 if (PyErr_Occurred()) SWIG_fail;
36672 }
36673 resultobj = SWIG_From_int(static_cast< int >(result));
36674 return resultobj;
36675 fail:
36676 return NULL;
36677 }
36678
36679
36680 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36681 PyObject *resultobj = 0;
36682 wxWindow *arg1 = (wxWindow *) 0 ;
36683 int result;
36684 void *argp1 = 0 ;
36685 int res1 = 0 ;
36686 PyObject *swig_obj[1] ;
36687
36688 if (!args) SWIG_fail;
36689 swig_obj[0] = args;
36690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36691 if (!SWIG_IsOK(res1)) {
36692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36693 }
36694 arg1 = reinterpret_cast< wxWindow * >(argp1);
36695 {
36696 PyThreadState* __tstate = wxPyBeginAllowThreads();
36697 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36698 wxPyEndAllowThreads(__tstate);
36699 if (PyErr_Occurred()) SWIG_fail;
36700 }
36701 resultobj = SWIG_From_int(static_cast< int >(result));
36702 return resultobj;
36703 fail:
36704 return NULL;
36705 }
36706
36707
36708 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36709 PyObject *resultobj = 0;
36710 wxWindow *arg1 = (wxWindow *) 0 ;
36711 wxString *arg2 = 0 ;
36712 int *arg3 = (int *) 0 ;
36713 int *arg4 = (int *) 0 ;
36714 void *argp1 = 0 ;
36715 int res1 = 0 ;
36716 bool temp2 = false ;
36717 int temp3 ;
36718 int res3 = SWIG_TMPOBJ ;
36719 int temp4 ;
36720 int res4 = SWIG_TMPOBJ ;
36721 PyObject * obj0 = 0 ;
36722 PyObject * obj1 = 0 ;
36723 char * kwnames[] = {
36724 (char *) "self",(char *) "string", NULL
36725 };
36726
36727 arg3 = &temp3;
36728 arg4 = &temp4;
36729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36731 if (!SWIG_IsOK(res1)) {
36732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36733 }
36734 arg1 = reinterpret_cast< wxWindow * >(argp1);
36735 {
36736 arg2 = wxString_in_helper(obj1);
36737 if (arg2 == NULL) SWIG_fail;
36738 temp2 = true;
36739 }
36740 {
36741 PyThreadState* __tstate = wxPyBeginAllowThreads();
36742 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36743 wxPyEndAllowThreads(__tstate);
36744 if (PyErr_Occurred()) SWIG_fail;
36745 }
36746 resultobj = SWIG_Py_Void();
36747 if (SWIG_IsTmpObj(res3)) {
36748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36749 } else {
36750 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36752 }
36753 if (SWIG_IsTmpObj(res4)) {
36754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36755 } else {
36756 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36757 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36758 }
36759 {
36760 if (temp2)
36761 delete arg2;
36762 }
36763 return resultobj;
36764 fail:
36765 {
36766 if (temp2)
36767 delete arg2;
36768 }
36769 return NULL;
36770 }
36771
36772
36773 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36774 PyObject *resultobj = 0;
36775 wxWindow *arg1 = (wxWindow *) 0 ;
36776 wxString *arg2 = 0 ;
36777 int *arg3 = (int *) 0 ;
36778 int *arg4 = (int *) 0 ;
36779 int *arg5 = (int *) 0 ;
36780 int *arg6 = (int *) 0 ;
36781 wxFont *arg7 = (wxFont *) NULL ;
36782 void *argp1 = 0 ;
36783 int res1 = 0 ;
36784 bool temp2 = false ;
36785 int temp3 ;
36786 int res3 = SWIG_TMPOBJ ;
36787 int temp4 ;
36788 int res4 = SWIG_TMPOBJ ;
36789 int temp5 ;
36790 int res5 = SWIG_TMPOBJ ;
36791 int temp6 ;
36792 int res6 = SWIG_TMPOBJ ;
36793 void *argp7 = 0 ;
36794 int res7 = 0 ;
36795 PyObject * obj0 = 0 ;
36796 PyObject * obj1 = 0 ;
36797 PyObject * obj2 = 0 ;
36798 char * kwnames[] = {
36799 (char *) "self",(char *) "string",(char *) "font", NULL
36800 };
36801
36802 arg3 = &temp3;
36803 arg4 = &temp4;
36804 arg5 = &temp5;
36805 arg6 = &temp6;
36806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36808 if (!SWIG_IsOK(res1)) {
36809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36810 }
36811 arg1 = reinterpret_cast< wxWindow * >(argp1);
36812 {
36813 arg2 = wxString_in_helper(obj1);
36814 if (arg2 == NULL) SWIG_fail;
36815 temp2 = true;
36816 }
36817 if (obj2) {
36818 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36819 if (!SWIG_IsOK(res7)) {
36820 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36821 }
36822 arg7 = reinterpret_cast< wxFont * >(argp7);
36823 }
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36827 wxPyEndAllowThreads(__tstate);
36828 if (PyErr_Occurred()) SWIG_fail;
36829 }
36830 resultobj = SWIG_Py_Void();
36831 if (SWIG_IsTmpObj(res3)) {
36832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36833 } else {
36834 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36836 }
36837 if (SWIG_IsTmpObj(res4)) {
36838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36839 } else {
36840 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36842 }
36843 if (SWIG_IsTmpObj(res5)) {
36844 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36845 } else {
36846 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36847 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36848 }
36849 if (SWIG_IsTmpObj(res6)) {
36850 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36851 } else {
36852 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36854 }
36855 {
36856 if (temp2)
36857 delete arg2;
36858 }
36859 return resultobj;
36860 fail:
36861 {
36862 if (temp2)
36863 delete arg2;
36864 }
36865 return NULL;
36866 }
36867
36868
36869 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36870 PyObject *resultobj = 0;
36871 wxWindow *arg1 = (wxWindow *) 0 ;
36872 int *arg2 = (int *) 0 ;
36873 int *arg3 = (int *) 0 ;
36874 void *argp1 = 0 ;
36875 int res1 = 0 ;
36876 int temp2 ;
36877 int res2 = 0 ;
36878 int temp3 ;
36879 int res3 = 0 ;
36880 PyObject * obj0 = 0 ;
36881 PyObject * obj1 = 0 ;
36882 PyObject * obj2 = 0 ;
36883 char * kwnames[] = {
36884 (char *) "self",(char *) "x",(char *) "y", NULL
36885 };
36886
36887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36889 if (!SWIG_IsOK(res1)) {
36890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36891 }
36892 arg1 = reinterpret_cast< wxWindow * >(argp1);
36893 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36894 int val;
36895 int ecode = SWIG_AsVal_int(obj1, &val);
36896 if (!SWIG_IsOK(ecode)) {
36897 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36898 }
36899 temp2 = static_cast< int >(val);
36900 arg2 = &temp2;
36901 res2 = SWIG_AddTmpMask(ecode);
36902 }
36903 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36904 int val;
36905 int ecode = SWIG_AsVal_int(obj2, &val);
36906 if (!SWIG_IsOK(ecode)) {
36907 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36908 }
36909 temp3 = static_cast< int >(val);
36910 arg3 = &temp3;
36911 res3 = SWIG_AddTmpMask(ecode);
36912 }
36913 {
36914 PyThreadState* __tstate = wxPyBeginAllowThreads();
36915 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36916 wxPyEndAllowThreads(__tstate);
36917 if (PyErr_Occurred()) SWIG_fail;
36918 }
36919 resultobj = SWIG_Py_Void();
36920 if (SWIG_IsTmpObj(res2)) {
36921 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36922 } else {
36923 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36925 }
36926 if (SWIG_IsTmpObj(res3)) {
36927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36928 } else {
36929 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36931 }
36932 return resultobj;
36933 fail:
36934 return NULL;
36935 }
36936
36937
36938 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36939 PyObject *resultobj = 0;
36940 wxWindow *arg1 = (wxWindow *) 0 ;
36941 int *arg2 = (int *) 0 ;
36942 int *arg3 = (int *) 0 ;
36943 void *argp1 = 0 ;
36944 int res1 = 0 ;
36945 int temp2 ;
36946 int res2 = 0 ;
36947 int temp3 ;
36948 int res3 = 0 ;
36949 PyObject * obj0 = 0 ;
36950 PyObject * obj1 = 0 ;
36951 PyObject * obj2 = 0 ;
36952 char * kwnames[] = {
36953 (char *) "self",(char *) "x",(char *) "y", NULL
36954 };
36955
36956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36958 if (!SWIG_IsOK(res1)) {
36959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36960 }
36961 arg1 = reinterpret_cast< wxWindow * >(argp1);
36962 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36963 int val;
36964 int ecode = SWIG_AsVal_int(obj1, &val);
36965 if (!SWIG_IsOK(ecode)) {
36966 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36967 }
36968 temp2 = static_cast< int >(val);
36969 arg2 = &temp2;
36970 res2 = SWIG_AddTmpMask(ecode);
36971 }
36972 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36973 int val;
36974 int ecode = SWIG_AsVal_int(obj2, &val);
36975 if (!SWIG_IsOK(ecode)) {
36976 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36977 }
36978 temp3 = static_cast< int >(val);
36979 arg3 = &temp3;
36980 res3 = SWIG_AddTmpMask(ecode);
36981 }
36982 {
36983 PyThreadState* __tstate = wxPyBeginAllowThreads();
36984 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36985 wxPyEndAllowThreads(__tstate);
36986 if (PyErr_Occurred()) SWIG_fail;
36987 }
36988 resultobj = SWIG_Py_Void();
36989 if (SWIG_IsTmpObj(res2)) {
36990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36991 } else {
36992 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36994 }
36995 if (SWIG_IsTmpObj(res3)) {
36996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36997 } else {
36998 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
37000 }
37001 return resultobj;
37002 fail:
37003 return NULL;
37004 }
37005
37006
37007 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37008 PyObject *resultobj = 0;
37009 wxWindow *arg1 = (wxWindow *) 0 ;
37010 wxPoint *arg2 = 0 ;
37011 wxPoint result;
37012 void *argp1 = 0 ;
37013 int res1 = 0 ;
37014 wxPoint temp2 ;
37015 PyObject * obj0 = 0 ;
37016 PyObject * obj1 = 0 ;
37017 char * kwnames[] = {
37018 (char *) "self",(char *) "pt", NULL
37019 };
37020
37021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37023 if (!SWIG_IsOK(res1)) {
37024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37025 }
37026 arg1 = reinterpret_cast< wxWindow * >(argp1);
37027 {
37028 arg2 = &temp2;
37029 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37030 }
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37034 wxPyEndAllowThreads(__tstate);
37035 if (PyErr_Occurred()) SWIG_fail;
37036 }
37037 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37038 return resultobj;
37039 fail:
37040 return NULL;
37041 }
37042
37043
37044 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37045 PyObject *resultobj = 0;
37046 wxWindow *arg1 = (wxWindow *) 0 ;
37047 wxPoint *arg2 = 0 ;
37048 wxPoint result;
37049 void *argp1 = 0 ;
37050 int res1 = 0 ;
37051 wxPoint temp2 ;
37052 PyObject * obj0 = 0 ;
37053 PyObject * obj1 = 0 ;
37054 char * kwnames[] = {
37055 (char *) "self",(char *) "pt", NULL
37056 };
37057
37058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 {
37065 arg2 = &temp2;
37066 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37067 }
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37075 return resultobj;
37076 fail:
37077 return NULL;
37078 }
37079
37080
37081 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37082 PyObject *resultobj = 0;
37083 wxWindow *arg1 = (wxWindow *) 0 ;
37084 int arg2 ;
37085 int arg3 ;
37086 wxHitTest result;
37087 void *argp1 = 0 ;
37088 int res1 = 0 ;
37089 int val2 ;
37090 int ecode2 = 0 ;
37091 int val3 ;
37092 int ecode3 = 0 ;
37093 PyObject * obj0 = 0 ;
37094 PyObject * obj1 = 0 ;
37095 PyObject * obj2 = 0 ;
37096 char * kwnames[] = {
37097 (char *) "self",(char *) "x",(char *) "y", NULL
37098 };
37099
37100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37102 if (!SWIG_IsOK(res1)) {
37103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37104 }
37105 arg1 = reinterpret_cast< wxWindow * >(argp1);
37106 ecode2 = SWIG_AsVal_int(obj1, &val2);
37107 if (!SWIG_IsOK(ecode2)) {
37108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37109 }
37110 arg2 = static_cast< int >(val2);
37111 ecode3 = SWIG_AsVal_int(obj2, &val3);
37112 if (!SWIG_IsOK(ecode3)) {
37113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37114 }
37115 arg3 = static_cast< int >(val3);
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37119 wxPyEndAllowThreads(__tstate);
37120 if (PyErr_Occurred()) SWIG_fail;
37121 }
37122 resultobj = SWIG_From_int(static_cast< int >(result));
37123 return resultobj;
37124 fail:
37125 return NULL;
37126 }
37127
37128
37129 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37130 PyObject *resultobj = 0;
37131 wxWindow *arg1 = (wxWindow *) 0 ;
37132 wxPoint *arg2 = 0 ;
37133 wxHitTest result;
37134 void *argp1 = 0 ;
37135 int res1 = 0 ;
37136 wxPoint temp2 ;
37137 PyObject * obj0 = 0 ;
37138 PyObject * obj1 = 0 ;
37139 char * kwnames[] = {
37140 (char *) "self",(char *) "pt", NULL
37141 };
37142
37143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37145 if (!SWIG_IsOK(res1)) {
37146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37147 }
37148 arg1 = reinterpret_cast< wxWindow * >(argp1);
37149 {
37150 arg2 = &temp2;
37151 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37152 }
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 resultobj = SWIG_From_int(static_cast< int >(result));
37160 return resultobj;
37161 fail:
37162 return NULL;
37163 }
37164
37165
37166 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37167 PyObject *resultobj = 0;
37168 wxWindow *arg1 = (wxWindow *) 0 ;
37169 long arg2 ;
37170 wxBorder result;
37171 void *argp1 = 0 ;
37172 int res1 = 0 ;
37173 long val2 ;
37174 int ecode2 = 0 ;
37175
37176 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37178 if (!SWIG_IsOK(res1)) {
37179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37180 }
37181 arg1 = reinterpret_cast< wxWindow * >(argp1);
37182 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37183 if (!SWIG_IsOK(ecode2)) {
37184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37185 }
37186 arg2 = static_cast< long >(val2);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 resultobj = SWIG_From_int(static_cast< int >(result));
37194 return resultobj;
37195 fail:
37196 return NULL;
37197 }
37198
37199
37200 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37201 PyObject *resultobj = 0;
37202 wxWindow *arg1 = (wxWindow *) 0 ;
37203 wxBorder result;
37204 void *argp1 = 0 ;
37205 int res1 = 0 ;
37206
37207 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37209 if (!SWIG_IsOK(res1)) {
37210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37211 }
37212 arg1 = reinterpret_cast< wxWindow * >(argp1);
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37216 wxPyEndAllowThreads(__tstate);
37217 if (PyErr_Occurred()) SWIG_fail;
37218 }
37219 resultobj = SWIG_From_int(static_cast< int >(result));
37220 return resultobj;
37221 fail:
37222 return NULL;
37223 }
37224
37225
37226 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37227 int argc;
37228 PyObject *argv[3];
37229
37230 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37231 --argc;
37232 if (argc == 1) {
37233 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37234 }
37235 if (argc == 2) {
37236 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37237 }
37238
37239 fail:
37240 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37241 return NULL;
37242 }
37243
37244
37245 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37246 PyObject *resultobj = 0;
37247 wxWindow *arg1 = (wxWindow *) 0 ;
37248 long arg2 = (long) wxUPDATE_UI_NONE ;
37249 void *argp1 = 0 ;
37250 int res1 = 0 ;
37251 long val2 ;
37252 int ecode2 = 0 ;
37253 PyObject * obj0 = 0 ;
37254 PyObject * obj1 = 0 ;
37255 char * kwnames[] = {
37256 (char *) "self",(char *) "flags", NULL
37257 };
37258
37259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37261 if (!SWIG_IsOK(res1)) {
37262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37263 }
37264 arg1 = reinterpret_cast< wxWindow * >(argp1);
37265 if (obj1) {
37266 ecode2 = SWIG_AsVal_long(obj1, &val2);
37267 if (!SWIG_IsOK(ecode2)) {
37268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37269 }
37270 arg2 = static_cast< long >(val2);
37271 }
37272 {
37273 PyThreadState* __tstate = wxPyBeginAllowThreads();
37274 (arg1)->UpdateWindowUI(arg2);
37275 wxPyEndAllowThreads(__tstate);
37276 if (PyErr_Occurred()) SWIG_fail;
37277 }
37278 resultobj = SWIG_Py_Void();
37279 return resultobj;
37280 fail:
37281 return NULL;
37282 }
37283
37284
37285 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37286 PyObject *resultobj = 0;
37287 wxWindow *arg1 = (wxWindow *) 0 ;
37288 wxMenu *arg2 = (wxMenu *) 0 ;
37289 int arg3 = (int) -1 ;
37290 int arg4 = (int) -1 ;
37291 bool result;
37292 void *argp1 = 0 ;
37293 int res1 = 0 ;
37294 void *argp2 = 0 ;
37295 int res2 = 0 ;
37296 int val3 ;
37297 int ecode3 = 0 ;
37298 int val4 ;
37299 int ecode4 = 0 ;
37300 PyObject * obj0 = 0 ;
37301 PyObject * obj1 = 0 ;
37302 PyObject * obj2 = 0 ;
37303 PyObject * obj3 = 0 ;
37304 char * kwnames[] = {
37305 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37306 };
37307
37308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37310 if (!SWIG_IsOK(res1)) {
37311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37312 }
37313 arg1 = reinterpret_cast< wxWindow * >(argp1);
37314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37315 if (!SWIG_IsOK(res2)) {
37316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37317 }
37318 arg2 = reinterpret_cast< wxMenu * >(argp2);
37319 if (obj2) {
37320 ecode3 = SWIG_AsVal_int(obj2, &val3);
37321 if (!SWIG_IsOK(ecode3)) {
37322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37323 }
37324 arg3 = static_cast< int >(val3);
37325 }
37326 if (obj3) {
37327 ecode4 = SWIG_AsVal_int(obj3, &val4);
37328 if (!SWIG_IsOK(ecode4)) {
37329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37330 }
37331 arg4 = static_cast< int >(val4);
37332 }
37333 {
37334 PyThreadState* __tstate = wxPyBeginAllowThreads();
37335 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37336 wxPyEndAllowThreads(__tstate);
37337 if (PyErr_Occurred()) SWIG_fail;
37338 }
37339 {
37340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37341 }
37342 return resultobj;
37343 fail:
37344 return NULL;
37345 }
37346
37347
37348 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37349 PyObject *resultobj = 0;
37350 wxWindow *arg1 = (wxWindow *) 0 ;
37351 wxMenu *arg2 = (wxMenu *) 0 ;
37352 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37353 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37354 bool result;
37355 void *argp1 = 0 ;
37356 int res1 = 0 ;
37357 void *argp2 = 0 ;
37358 int res2 = 0 ;
37359 wxPoint temp3 ;
37360 PyObject * obj0 = 0 ;
37361 PyObject * obj1 = 0 ;
37362 PyObject * obj2 = 0 ;
37363 char * kwnames[] = {
37364 (char *) "self",(char *) "menu",(char *) "pos", NULL
37365 };
37366
37367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37369 if (!SWIG_IsOK(res1)) {
37370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37371 }
37372 arg1 = reinterpret_cast< wxWindow * >(argp1);
37373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37374 if (!SWIG_IsOK(res2)) {
37375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37376 }
37377 arg2 = reinterpret_cast< wxMenu * >(argp2);
37378 if (obj2) {
37379 {
37380 arg3 = &temp3;
37381 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37382 }
37383 }
37384 {
37385 PyThreadState* __tstate = wxPyBeginAllowThreads();
37386 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37387 wxPyEndAllowThreads(__tstate);
37388 if (PyErr_Occurred()) SWIG_fail;
37389 }
37390 {
37391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37392 }
37393 return resultobj;
37394 fail:
37395 return NULL;
37396 }
37397
37398
37399 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37400 PyObject *resultobj = 0;
37401 wxWindow *arg1 = (wxWindow *) 0 ;
37402 bool result;
37403 void *argp1 = 0 ;
37404 int res1 = 0 ;
37405 PyObject *swig_obj[1] ;
37406
37407 if (!args) SWIG_fail;
37408 swig_obj[0] = args;
37409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37410 if (!SWIG_IsOK(res1)) {
37411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37412 }
37413 arg1 = reinterpret_cast< wxWindow * >(argp1);
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 {
37421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37422 }
37423 return resultobj;
37424 fail:
37425 return NULL;
37426 }
37427
37428
37429 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37430 PyObject *resultobj = 0;
37431 wxWindow *arg1 = (wxWindow *) 0 ;
37432 long result;
37433 void *argp1 = 0 ;
37434 int res1 = 0 ;
37435 PyObject *swig_obj[1] ;
37436
37437 if (!args) SWIG_fail;
37438 swig_obj[0] = args;
37439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37440 if (!SWIG_IsOK(res1)) {
37441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37442 }
37443 arg1 = reinterpret_cast< wxWindow * >(argp1);
37444 {
37445 PyThreadState* __tstate = wxPyBeginAllowThreads();
37446 result = (long)wxWindow_GetHandle(arg1);
37447 wxPyEndAllowThreads(__tstate);
37448 if (PyErr_Occurred()) SWIG_fail;
37449 }
37450 resultobj = SWIG_From_long(static_cast< long >(result));
37451 return resultobj;
37452 fail:
37453 return NULL;
37454 }
37455
37456
37457 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37458 PyObject *resultobj = 0;
37459 wxWindow *arg1 = (wxWindow *) 0 ;
37460 long arg2 ;
37461 void *argp1 = 0 ;
37462 int res1 = 0 ;
37463 long val2 ;
37464 int ecode2 = 0 ;
37465 PyObject * obj0 = 0 ;
37466 PyObject * obj1 = 0 ;
37467 char * kwnames[] = {
37468 (char *) "self",(char *) "handle", NULL
37469 };
37470
37471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37473 if (!SWIG_IsOK(res1)) {
37474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37475 }
37476 arg1 = reinterpret_cast< wxWindow * >(argp1);
37477 ecode2 = SWIG_AsVal_long(obj1, &val2);
37478 if (!SWIG_IsOK(ecode2)) {
37479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37480 }
37481 arg2 = static_cast< long >(val2);
37482 {
37483 PyThreadState* __tstate = wxPyBeginAllowThreads();
37484 wxWindow_AssociateHandle(arg1,arg2);
37485 wxPyEndAllowThreads(__tstate);
37486 if (PyErr_Occurred()) SWIG_fail;
37487 }
37488 resultobj = SWIG_Py_Void();
37489 return resultobj;
37490 fail:
37491 return NULL;
37492 }
37493
37494
37495 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37496 PyObject *resultobj = 0;
37497 wxWindow *arg1 = (wxWindow *) 0 ;
37498 void *argp1 = 0 ;
37499 int res1 = 0 ;
37500 PyObject *swig_obj[1] ;
37501
37502 if (!args) SWIG_fail;
37503 swig_obj[0] = args;
37504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37505 if (!SWIG_IsOK(res1)) {
37506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37507 }
37508 arg1 = reinterpret_cast< wxWindow * >(argp1);
37509 {
37510 PyThreadState* __tstate = wxPyBeginAllowThreads();
37511 (arg1)->DissociateHandle();
37512 wxPyEndAllowThreads(__tstate);
37513 if (PyErr_Occurred()) SWIG_fail;
37514 }
37515 resultobj = SWIG_Py_Void();
37516 return resultobj;
37517 fail:
37518 return NULL;
37519 }
37520
37521
37522 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37523 PyObject *resultobj = 0;
37524 wxWindow *arg1 = (wxWindow *) 0 ;
37525 int arg2 ;
37526 bool result;
37527 void *argp1 = 0 ;
37528 int res1 = 0 ;
37529 int val2 ;
37530 int ecode2 = 0 ;
37531 PyObject * obj0 = 0 ;
37532 PyObject * obj1 = 0 ;
37533 char * kwnames[] = {
37534 (char *) "self",(char *) "orient", NULL
37535 };
37536
37537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37539 if (!SWIG_IsOK(res1)) {
37540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37541 }
37542 arg1 = reinterpret_cast< wxWindow * >(argp1);
37543 ecode2 = SWIG_AsVal_int(obj1, &val2);
37544 if (!SWIG_IsOK(ecode2)) {
37545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37546 }
37547 arg2 = static_cast< int >(val2);
37548 {
37549 PyThreadState* __tstate = wxPyBeginAllowThreads();
37550 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37551 wxPyEndAllowThreads(__tstate);
37552 if (PyErr_Occurred()) SWIG_fail;
37553 }
37554 {
37555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37556 }
37557 return resultobj;
37558 fail:
37559 return NULL;
37560 }
37561
37562
37563 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37564 PyObject *resultobj = 0;
37565 wxWindow *arg1 = (wxWindow *) 0 ;
37566 int arg2 ;
37567 int arg3 ;
37568 int arg4 ;
37569 int arg5 ;
37570 bool arg6 = (bool) true ;
37571 void *argp1 = 0 ;
37572 int res1 = 0 ;
37573 int val2 ;
37574 int ecode2 = 0 ;
37575 int val3 ;
37576 int ecode3 = 0 ;
37577 int val4 ;
37578 int ecode4 = 0 ;
37579 int val5 ;
37580 int ecode5 = 0 ;
37581 bool val6 ;
37582 int ecode6 = 0 ;
37583 PyObject * obj0 = 0 ;
37584 PyObject * obj1 = 0 ;
37585 PyObject * obj2 = 0 ;
37586 PyObject * obj3 = 0 ;
37587 PyObject * obj4 = 0 ;
37588 PyObject * obj5 = 0 ;
37589 char * kwnames[] = {
37590 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37591 };
37592
37593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37595 if (!SWIG_IsOK(res1)) {
37596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37597 }
37598 arg1 = reinterpret_cast< wxWindow * >(argp1);
37599 ecode2 = SWIG_AsVal_int(obj1, &val2);
37600 if (!SWIG_IsOK(ecode2)) {
37601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37602 }
37603 arg2 = static_cast< int >(val2);
37604 ecode3 = SWIG_AsVal_int(obj2, &val3);
37605 if (!SWIG_IsOK(ecode3)) {
37606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37607 }
37608 arg3 = static_cast< int >(val3);
37609 ecode4 = SWIG_AsVal_int(obj3, &val4);
37610 if (!SWIG_IsOK(ecode4)) {
37611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37612 }
37613 arg4 = static_cast< int >(val4);
37614 ecode5 = SWIG_AsVal_int(obj4, &val5);
37615 if (!SWIG_IsOK(ecode5)) {
37616 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37617 }
37618 arg5 = static_cast< int >(val5);
37619 if (obj5) {
37620 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37621 if (!SWIG_IsOK(ecode6)) {
37622 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37623 }
37624 arg6 = static_cast< bool >(val6);
37625 }
37626 {
37627 PyThreadState* __tstate = wxPyBeginAllowThreads();
37628 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37629 wxPyEndAllowThreads(__tstate);
37630 if (PyErr_Occurred()) SWIG_fail;
37631 }
37632 resultobj = SWIG_Py_Void();
37633 return resultobj;
37634 fail:
37635 return NULL;
37636 }
37637
37638
37639 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37640 PyObject *resultobj = 0;
37641 wxWindow *arg1 = (wxWindow *) 0 ;
37642 int arg2 ;
37643 int arg3 ;
37644 bool arg4 = (bool) true ;
37645 void *argp1 = 0 ;
37646 int res1 = 0 ;
37647 int val2 ;
37648 int ecode2 = 0 ;
37649 int val3 ;
37650 int ecode3 = 0 ;
37651 bool val4 ;
37652 int ecode4 = 0 ;
37653 PyObject * obj0 = 0 ;
37654 PyObject * obj1 = 0 ;
37655 PyObject * obj2 = 0 ;
37656 PyObject * obj3 = 0 ;
37657 char * kwnames[] = {
37658 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37659 };
37660
37661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37663 if (!SWIG_IsOK(res1)) {
37664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37665 }
37666 arg1 = reinterpret_cast< wxWindow * >(argp1);
37667 ecode2 = SWIG_AsVal_int(obj1, &val2);
37668 if (!SWIG_IsOK(ecode2)) {
37669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37670 }
37671 arg2 = static_cast< int >(val2);
37672 ecode3 = SWIG_AsVal_int(obj2, &val3);
37673 if (!SWIG_IsOK(ecode3)) {
37674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37675 }
37676 arg3 = static_cast< int >(val3);
37677 if (obj3) {
37678 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37679 if (!SWIG_IsOK(ecode4)) {
37680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37681 }
37682 arg4 = static_cast< bool >(val4);
37683 }
37684 {
37685 PyThreadState* __tstate = wxPyBeginAllowThreads();
37686 (arg1)->SetScrollPos(arg2,arg3,arg4);
37687 wxPyEndAllowThreads(__tstate);
37688 if (PyErr_Occurred()) SWIG_fail;
37689 }
37690 resultobj = SWIG_Py_Void();
37691 return resultobj;
37692 fail:
37693 return NULL;
37694 }
37695
37696
37697 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37698 PyObject *resultobj = 0;
37699 wxWindow *arg1 = (wxWindow *) 0 ;
37700 int arg2 ;
37701 int result;
37702 void *argp1 = 0 ;
37703 int res1 = 0 ;
37704 int val2 ;
37705 int ecode2 = 0 ;
37706 PyObject * obj0 = 0 ;
37707 PyObject * obj1 = 0 ;
37708 char * kwnames[] = {
37709 (char *) "self",(char *) "orientation", NULL
37710 };
37711
37712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37714 if (!SWIG_IsOK(res1)) {
37715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37716 }
37717 arg1 = reinterpret_cast< wxWindow * >(argp1);
37718 ecode2 = SWIG_AsVal_int(obj1, &val2);
37719 if (!SWIG_IsOK(ecode2)) {
37720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37721 }
37722 arg2 = static_cast< int >(val2);
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 resultobj = SWIG_From_int(static_cast< int >(result));
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37737 PyObject *resultobj = 0;
37738 wxWindow *arg1 = (wxWindow *) 0 ;
37739 int arg2 ;
37740 int result;
37741 void *argp1 = 0 ;
37742 int res1 = 0 ;
37743 int val2 ;
37744 int ecode2 = 0 ;
37745 PyObject * obj0 = 0 ;
37746 PyObject * obj1 = 0 ;
37747 char * kwnames[] = {
37748 (char *) "self",(char *) "orientation", NULL
37749 };
37750
37751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37753 if (!SWIG_IsOK(res1)) {
37754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37755 }
37756 arg1 = reinterpret_cast< wxWindow * >(argp1);
37757 ecode2 = SWIG_AsVal_int(obj1, &val2);
37758 if (!SWIG_IsOK(ecode2)) {
37759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37760 }
37761 arg2 = static_cast< int >(val2);
37762 {
37763 PyThreadState* __tstate = wxPyBeginAllowThreads();
37764 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37765 wxPyEndAllowThreads(__tstate);
37766 if (PyErr_Occurred()) SWIG_fail;
37767 }
37768 resultobj = SWIG_From_int(static_cast< int >(result));
37769 return resultobj;
37770 fail:
37771 return NULL;
37772 }
37773
37774
37775 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37776 PyObject *resultobj = 0;
37777 wxWindow *arg1 = (wxWindow *) 0 ;
37778 int arg2 ;
37779 int result;
37780 void *argp1 = 0 ;
37781 int res1 = 0 ;
37782 int val2 ;
37783 int ecode2 = 0 ;
37784 PyObject * obj0 = 0 ;
37785 PyObject * obj1 = 0 ;
37786 char * kwnames[] = {
37787 (char *) "self",(char *) "orientation", NULL
37788 };
37789
37790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37792 if (!SWIG_IsOK(res1)) {
37793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37794 }
37795 arg1 = reinterpret_cast< wxWindow * >(argp1);
37796 ecode2 = SWIG_AsVal_int(obj1, &val2);
37797 if (!SWIG_IsOK(ecode2)) {
37798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37799 }
37800 arg2 = static_cast< int >(val2);
37801 {
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 resultobj = SWIG_From_int(static_cast< int >(result));
37808 return resultobj;
37809 fail:
37810 return NULL;
37811 }
37812
37813
37814 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37815 PyObject *resultobj = 0;
37816 wxWindow *arg1 = (wxWindow *) 0 ;
37817 int arg2 ;
37818 int arg3 ;
37819 wxRect *arg4 = (wxRect *) NULL ;
37820 void *argp1 = 0 ;
37821 int res1 = 0 ;
37822 int val2 ;
37823 int ecode2 = 0 ;
37824 int val3 ;
37825 int ecode3 = 0 ;
37826 void *argp4 = 0 ;
37827 int res4 = 0 ;
37828 PyObject * obj0 = 0 ;
37829 PyObject * obj1 = 0 ;
37830 PyObject * obj2 = 0 ;
37831 PyObject * obj3 = 0 ;
37832 char * kwnames[] = {
37833 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37834 };
37835
37836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37838 if (!SWIG_IsOK(res1)) {
37839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37840 }
37841 arg1 = reinterpret_cast< wxWindow * >(argp1);
37842 ecode2 = SWIG_AsVal_int(obj1, &val2);
37843 if (!SWIG_IsOK(ecode2)) {
37844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37845 }
37846 arg2 = static_cast< int >(val2);
37847 ecode3 = SWIG_AsVal_int(obj2, &val3);
37848 if (!SWIG_IsOK(ecode3)) {
37849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37850 }
37851 arg3 = static_cast< int >(val3);
37852 if (obj3) {
37853 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37854 if (!SWIG_IsOK(res4)) {
37855 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37856 }
37857 arg4 = reinterpret_cast< wxRect * >(argp4);
37858 }
37859 {
37860 PyThreadState* __tstate = wxPyBeginAllowThreads();
37861 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37862 wxPyEndAllowThreads(__tstate);
37863 if (PyErr_Occurred()) SWIG_fail;
37864 }
37865 resultobj = SWIG_Py_Void();
37866 return resultobj;
37867 fail:
37868 return NULL;
37869 }
37870
37871
37872 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37873 PyObject *resultobj = 0;
37874 wxWindow *arg1 = (wxWindow *) 0 ;
37875 int arg2 ;
37876 bool result;
37877 void *argp1 = 0 ;
37878 int res1 = 0 ;
37879 int val2 ;
37880 int ecode2 = 0 ;
37881 PyObject * obj0 = 0 ;
37882 PyObject * obj1 = 0 ;
37883 char * kwnames[] = {
37884 (char *) "self",(char *) "lines", NULL
37885 };
37886
37887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37889 if (!SWIG_IsOK(res1)) {
37890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37891 }
37892 arg1 = reinterpret_cast< wxWindow * >(argp1);
37893 ecode2 = SWIG_AsVal_int(obj1, &val2);
37894 if (!SWIG_IsOK(ecode2)) {
37895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37896 }
37897 arg2 = static_cast< int >(val2);
37898 {
37899 PyThreadState* __tstate = wxPyBeginAllowThreads();
37900 result = (bool)(arg1)->ScrollLines(arg2);
37901 wxPyEndAllowThreads(__tstate);
37902 if (PyErr_Occurred()) SWIG_fail;
37903 }
37904 {
37905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37906 }
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37914 PyObject *resultobj = 0;
37915 wxWindow *arg1 = (wxWindow *) 0 ;
37916 int arg2 ;
37917 bool result;
37918 void *argp1 = 0 ;
37919 int res1 = 0 ;
37920 int val2 ;
37921 int ecode2 = 0 ;
37922 PyObject * obj0 = 0 ;
37923 PyObject * obj1 = 0 ;
37924 char * kwnames[] = {
37925 (char *) "self",(char *) "pages", NULL
37926 };
37927
37928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37930 if (!SWIG_IsOK(res1)) {
37931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37932 }
37933 arg1 = reinterpret_cast< wxWindow * >(argp1);
37934 ecode2 = SWIG_AsVal_int(obj1, &val2);
37935 if (!SWIG_IsOK(ecode2)) {
37936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37937 }
37938 arg2 = static_cast< int >(val2);
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 result = (bool)(arg1)->ScrollPages(arg2);
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 {
37946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37947 }
37948 return resultobj;
37949 fail:
37950 return NULL;
37951 }
37952
37953
37954 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37955 PyObject *resultobj = 0;
37956 wxWindow *arg1 = (wxWindow *) 0 ;
37957 bool result;
37958 void *argp1 = 0 ;
37959 int res1 = 0 ;
37960 PyObject *swig_obj[1] ;
37961
37962 if (!args) SWIG_fail;
37963 swig_obj[0] = args;
37964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37965 if (!SWIG_IsOK(res1)) {
37966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37967 }
37968 arg1 = reinterpret_cast< wxWindow * >(argp1);
37969 {
37970 PyThreadState* __tstate = wxPyBeginAllowThreads();
37971 result = (bool)(arg1)->LineUp();
37972 wxPyEndAllowThreads(__tstate);
37973 if (PyErr_Occurred()) SWIG_fail;
37974 }
37975 {
37976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37977 }
37978 return resultobj;
37979 fail:
37980 return NULL;
37981 }
37982
37983
37984 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37985 PyObject *resultobj = 0;
37986 wxWindow *arg1 = (wxWindow *) 0 ;
37987 bool result;
37988 void *argp1 = 0 ;
37989 int res1 = 0 ;
37990 PyObject *swig_obj[1] ;
37991
37992 if (!args) SWIG_fail;
37993 swig_obj[0] = args;
37994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37995 if (!SWIG_IsOK(res1)) {
37996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37997 }
37998 arg1 = reinterpret_cast< wxWindow * >(argp1);
37999 {
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = (bool)(arg1)->LineDown();
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 {
38006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38007 }
38008 return resultobj;
38009 fail:
38010 return NULL;
38011 }
38012
38013
38014 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38015 PyObject *resultobj = 0;
38016 wxWindow *arg1 = (wxWindow *) 0 ;
38017 bool result;
38018 void *argp1 = 0 ;
38019 int res1 = 0 ;
38020 PyObject *swig_obj[1] ;
38021
38022 if (!args) SWIG_fail;
38023 swig_obj[0] = args;
38024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38025 if (!SWIG_IsOK(res1)) {
38026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38027 }
38028 arg1 = reinterpret_cast< wxWindow * >(argp1);
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 result = (bool)(arg1)->PageUp();
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 {
38036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38037 }
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38045 PyObject *resultobj = 0;
38046 wxWindow *arg1 = (wxWindow *) 0 ;
38047 bool result;
38048 void *argp1 = 0 ;
38049 int res1 = 0 ;
38050 PyObject *swig_obj[1] ;
38051
38052 if (!args) SWIG_fail;
38053 swig_obj[0] = args;
38054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38055 if (!SWIG_IsOK(res1)) {
38056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38057 }
38058 arg1 = reinterpret_cast< wxWindow * >(argp1);
38059 {
38060 PyThreadState* __tstate = wxPyBeginAllowThreads();
38061 result = (bool)(arg1)->PageDown();
38062 wxPyEndAllowThreads(__tstate);
38063 if (PyErr_Occurred()) SWIG_fail;
38064 }
38065 {
38066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38067 }
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38075 PyObject *resultobj = 0;
38076 wxWindow *arg1 = (wxWindow *) 0 ;
38077 wxString *arg2 = 0 ;
38078 void *argp1 = 0 ;
38079 int res1 = 0 ;
38080 bool temp2 = false ;
38081 PyObject * obj0 = 0 ;
38082 PyObject * obj1 = 0 ;
38083 char * kwnames[] = {
38084 (char *) "self",(char *) "text", NULL
38085 };
38086
38087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38089 if (!SWIG_IsOK(res1)) {
38090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38091 }
38092 arg1 = reinterpret_cast< wxWindow * >(argp1);
38093 {
38094 arg2 = wxString_in_helper(obj1);
38095 if (arg2 == NULL) SWIG_fail;
38096 temp2 = true;
38097 }
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 (arg1)->SetHelpText((wxString const &)*arg2);
38101 wxPyEndAllowThreads(__tstate);
38102 if (PyErr_Occurred()) SWIG_fail;
38103 }
38104 resultobj = SWIG_Py_Void();
38105 {
38106 if (temp2)
38107 delete arg2;
38108 }
38109 return resultobj;
38110 fail:
38111 {
38112 if (temp2)
38113 delete arg2;
38114 }
38115 return NULL;
38116 }
38117
38118
38119 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38120 PyObject *resultobj = 0;
38121 wxWindow *arg1 = (wxWindow *) 0 ;
38122 wxString *arg2 = 0 ;
38123 void *argp1 = 0 ;
38124 int res1 = 0 ;
38125 bool temp2 = false ;
38126 PyObject * obj0 = 0 ;
38127 PyObject * obj1 = 0 ;
38128 char * kwnames[] = {
38129 (char *) "self",(char *) "text", NULL
38130 };
38131
38132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38134 if (!SWIG_IsOK(res1)) {
38135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38136 }
38137 arg1 = reinterpret_cast< wxWindow * >(argp1);
38138 {
38139 arg2 = wxString_in_helper(obj1);
38140 if (arg2 == NULL) SWIG_fail;
38141 temp2 = true;
38142 }
38143 {
38144 PyThreadState* __tstate = wxPyBeginAllowThreads();
38145 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38146 wxPyEndAllowThreads(__tstate);
38147 if (PyErr_Occurred()) SWIG_fail;
38148 }
38149 resultobj = SWIG_Py_Void();
38150 {
38151 if (temp2)
38152 delete arg2;
38153 }
38154 return resultobj;
38155 fail:
38156 {
38157 if (temp2)
38158 delete arg2;
38159 }
38160 return NULL;
38161 }
38162
38163
38164 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38165 PyObject *resultobj = 0;
38166 wxWindow *arg1 = (wxWindow *) 0 ;
38167 wxPoint *arg2 = 0 ;
38168 wxHelpEvent::Origin arg3 ;
38169 wxString result;
38170 void *argp1 = 0 ;
38171 int res1 = 0 ;
38172 wxPoint temp2 ;
38173 void *argp3 ;
38174 int res3 = 0 ;
38175 PyObject * obj0 = 0 ;
38176 PyObject * obj1 = 0 ;
38177 PyObject * obj2 = 0 ;
38178 char * kwnames[] = {
38179 (char *) "self",(char *) "pt",(char *) "origin", NULL
38180 };
38181
38182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38184 if (!SWIG_IsOK(res1)) {
38185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38186 }
38187 arg1 = reinterpret_cast< wxWindow * >(argp1);
38188 {
38189 arg2 = &temp2;
38190 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38191 }
38192 {
38193 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38194 if (!SWIG_IsOK(res3)) {
38195 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38196 }
38197 if (!argp3) {
38198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38199 } else {
38200 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38201 arg3 = *temp;
38202 if (SWIG_IsNewObj(res3)) delete temp;
38203 }
38204 }
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 {
38212 #if wxUSE_UNICODE
38213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38214 #else
38215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38216 #endif
38217 }
38218 return resultobj;
38219 fail:
38220 return NULL;
38221 }
38222
38223
38224 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38225 PyObject *resultobj = 0;
38226 wxWindow *arg1 = (wxWindow *) 0 ;
38227 wxString result;
38228 void *argp1 = 0 ;
38229 int res1 = 0 ;
38230 PyObject *swig_obj[1] ;
38231
38232 if (!args) SWIG_fail;
38233 swig_obj[0] = args;
38234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38235 if (!SWIG_IsOK(res1)) {
38236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38237 }
38238 arg1 = reinterpret_cast< wxWindow * >(argp1);
38239 {
38240 PyThreadState* __tstate = wxPyBeginAllowThreads();
38241 result = ((wxWindow const *)arg1)->GetHelpText();
38242 wxPyEndAllowThreads(__tstate);
38243 if (PyErr_Occurred()) SWIG_fail;
38244 }
38245 {
38246 #if wxUSE_UNICODE
38247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38248 #else
38249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38250 #endif
38251 }
38252 return resultobj;
38253 fail:
38254 return NULL;
38255 }
38256
38257
38258 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38259 PyObject *resultobj = 0;
38260 wxWindow *arg1 = (wxWindow *) 0 ;
38261 wxString *arg2 = 0 ;
38262 void *argp1 = 0 ;
38263 int res1 = 0 ;
38264 bool temp2 = false ;
38265 PyObject * obj0 = 0 ;
38266 PyObject * obj1 = 0 ;
38267 char * kwnames[] = {
38268 (char *) "self",(char *) "tip", NULL
38269 };
38270
38271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38273 if (!SWIG_IsOK(res1)) {
38274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38275 }
38276 arg1 = reinterpret_cast< wxWindow * >(argp1);
38277 {
38278 arg2 = wxString_in_helper(obj1);
38279 if (arg2 == NULL) SWIG_fail;
38280 temp2 = true;
38281 }
38282 {
38283 PyThreadState* __tstate = wxPyBeginAllowThreads();
38284 (arg1)->SetToolTip((wxString const &)*arg2);
38285 wxPyEndAllowThreads(__tstate);
38286 if (PyErr_Occurred()) SWIG_fail;
38287 }
38288 resultobj = SWIG_Py_Void();
38289 {
38290 if (temp2)
38291 delete arg2;
38292 }
38293 return resultobj;
38294 fail:
38295 {
38296 if (temp2)
38297 delete arg2;
38298 }
38299 return NULL;
38300 }
38301
38302
38303 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38304 PyObject *resultobj = 0;
38305 wxWindow *arg1 = (wxWindow *) 0 ;
38306 wxToolTip *arg2 = (wxToolTip *) 0 ;
38307 void *argp1 = 0 ;
38308 int res1 = 0 ;
38309 int res2 = 0 ;
38310 PyObject * obj0 = 0 ;
38311 PyObject * obj1 = 0 ;
38312 char * kwnames[] = {
38313 (char *) "self",(char *) "tip", NULL
38314 };
38315
38316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38318 if (!SWIG_IsOK(res1)) {
38319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38320 }
38321 arg1 = reinterpret_cast< wxWindow * >(argp1);
38322 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38323 if (!SWIG_IsOK(res2)) {
38324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38325 }
38326 {
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 (arg1)->SetToolTip(arg2);
38329 wxPyEndAllowThreads(__tstate);
38330 if (PyErr_Occurred()) SWIG_fail;
38331 }
38332 resultobj = SWIG_Py_Void();
38333 return resultobj;
38334 fail:
38335 return NULL;
38336 }
38337
38338
38339 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38340 PyObject *resultobj = 0;
38341 wxWindow *arg1 = (wxWindow *) 0 ;
38342 wxToolTip *result = 0 ;
38343 void *argp1 = 0 ;
38344 int res1 = 0 ;
38345 PyObject *swig_obj[1] ;
38346
38347 if (!args) SWIG_fail;
38348 swig_obj[0] = args;
38349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38350 if (!SWIG_IsOK(res1)) {
38351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38352 }
38353 arg1 = reinterpret_cast< wxWindow * >(argp1);
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38357 wxPyEndAllowThreads(__tstate);
38358 if (PyErr_Occurred()) SWIG_fail;
38359 }
38360 {
38361 resultobj = wxPyMake_wxObject(result, (bool)0);
38362 }
38363 return resultobj;
38364 fail:
38365 return NULL;
38366 }
38367
38368
38369 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38370 PyObject *resultobj = 0;
38371 wxWindow *arg1 = (wxWindow *) 0 ;
38372 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38373 void *argp1 = 0 ;
38374 int res1 = 0 ;
38375 int res2 = 0 ;
38376 PyObject * obj0 = 0 ;
38377 PyObject * obj1 = 0 ;
38378 char * kwnames[] = {
38379 (char *) "self",(char *) "dropTarget", NULL
38380 };
38381
38382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38384 if (!SWIG_IsOK(res1)) {
38385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38386 }
38387 arg1 = reinterpret_cast< wxWindow * >(argp1);
38388 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38389 if (!SWIG_IsOK(res2)) {
38390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38391 }
38392 {
38393 PyThreadState* __tstate = wxPyBeginAllowThreads();
38394 (arg1)->SetDropTarget(arg2);
38395 wxPyEndAllowThreads(__tstate);
38396 if (PyErr_Occurred()) SWIG_fail;
38397 }
38398 resultobj = SWIG_Py_Void();
38399 return resultobj;
38400 fail:
38401 return NULL;
38402 }
38403
38404
38405 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38406 PyObject *resultobj = 0;
38407 wxWindow *arg1 = (wxWindow *) 0 ;
38408 wxPyDropTarget *result = 0 ;
38409 void *argp1 = 0 ;
38410 int res1 = 0 ;
38411 PyObject *swig_obj[1] ;
38412
38413 if (!args) SWIG_fail;
38414 swig_obj[0] = args;
38415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38416 if (!SWIG_IsOK(res1)) {
38417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38418 }
38419 arg1 = reinterpret_cast< wxWindow * >(argp1);
38420 {
38421 PyThreadState* __tstate = wxPyBeginAllowThreads();
38422 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38423 wxPyEndAllowThreads(__tstate);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 }
38426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38427 return resultobj;
38428 fail:
38429 return NULL;
38430 }
38431
38432
38433 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38434 PyObject *resultobj = 0;
38435 wxWindow *arg1 = (wxWindow *) 0 ;
38436 bool arg2 ;
38437 void *argp1 = 0 ;
38438 int res1 = 0 ;
38439 bool val2 ;
38440 int ecode2 = 0 ;
38441 PyObject * obj0 = 0 ;
38442 PyObject * obj1 = 0 ;
38443 char * kwnames[] = {
38444 (char *) "self",(char *) "accept", NULL
38445 };
38446
38447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38449 if (!SWIG_IsOK(res1)) {
38450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38451 }
38452 arg1 = reinterpret_cast< wxWindow * >(argp1);
38453 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38454 if (!SWIG_IsOK(ecode2)) {
38455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38456 }
38457 arg2 = static_cast< bool >(val2);
38458 {
38459 PyThreadState* __tstate = wxPyBeginAllowThreads();
38460 wxWindow_DragAcceptFiles(arg1,arg2);
38461 wxPyEndAllowThreads(__tstate);
38462 if (PyErr_Occurred()) SWIG_fail;
38463 }
38464 resultobj = SWIG_Py_Void();
38465 return resultobj;
38466 fail:
38467 return NULL;
38468 }
38469
38470
38471 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38472 PyObject *resultobj = 0;
38473 wxWindow *arg1 = (wxWindow *) 0 ;
38474 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38475 void *argp1 = 0 ;
38476 int res1 = 0 ;
38477 int res2 = 0 ;
38478 PyObject * obj0 = 0 ;
38479 PyObject * obj1 = 0 ;
38480 char * kwnames[] = {
38481 (char *) "self",(char *) "constraints", NULL
38482 };
38483
38484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38486 if (!SWIG_IsOK(res1)) {
38487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38488 }
38489 arg1 = reinterpret_cast< wxWindow * >(argp1);
38490 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38491 if (!SWIG_IsOK(res2)) {
38492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38493 }
38494 {
38495 PyThreadState* __tstate = wxPyBeginAllowThreads();
38496 (arg1)->SetConstraints(arg2);
38497 wxPyEndAllowThreads(__tstate);
38498 if (PyErr_Occurred()) SWIG_fail;
38499 }
38500 resultobj = SWIG_Py_Void();
38501 return resultobj;
38502 fail:
38503 return NULL;
38504 }
38505
38506
38507 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38508 PyObject *resultobj = 0;
38509 wxWindow *arg1 = (wxWindow *) 0 ;
38510 wxLayoutConstraints *result = 0 ;
38511 void *argp1 = 0 ;
38512 int res1 = 0 ;
38513 PyObject *swig_obj[1] ;
38514
38515 if (!args) SWIG_fail;
38516 swig_obj[0] = args;
38517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38518 if (!SWIG_IsOK(res1)) {
38519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38520 }
38521 arg1 = reinterpret_cast< wxWindow * >(argp1);
38522 {
38523 PyThreadState* __tstate = wxPyBeginAllowThreads();
38524 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38525 wxPyEndAllowThreads(__tstate);
38526 if (PyErr_Occurred()) SWIG_fail;
38527 }
38528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38529 return resultobj;
38530 fail:
38531 return NULL;
38532 }
38533
38534
38535 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38536 PyObject *resultobj = 0;
38537 wxWindow *arg1 = (wxWindow *) 0 ;
38538 bool arg2 ;
38539 void *argp1 = 0 ;
38540 int res1 = 0 ;
38541 bool val2 ;
38542 int ecode2 = 0 ;
38543 PyObject * obj0 = 0 ;
38544 PyObject * obj1 = 0 ;
38545 char * kwnames[] = {
38546 (char *) "self",(char *) "autoLayout", NULL
38547 };
38548
38549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38551 if (!SWIG_IsOK(res1)) {
38552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38553 }
38554 arg1 = reinterpret_cast< wxWindow * >(argp1);
38555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38556 if (!SWIG_IsOK(ecode2)) {
38557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38558 }
38559 arg2 = static_cast< bool >(val2);
38560 {
38561 PyThreadState* __tstate = wxPyBeginAllowThreads();
38562 (arg1)->SetAutoLayout(arg2);
38563 wxPyEndAllowThreads(__tstate);
38564 if (PyErr_Occurred()) SWIG_fail;
38565 }
38566 resultobj = SWIG_Py_Void();
38567 return resultobj;
38568 fail:
38569 return NULL;
38570 }
38571
38572
38573 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38574 PyObject *resultobj = 0;
38575 wxWindow *arg1 = (wxWindow *) 0 ;
38576 bool result;
38577 void *argp1 = 0 ;
38578 int res1 = 0 ;
38579 PyObject *swig_obj[1] ;
38580
38581 if (!args) SWIG_fail;
38582 swig_obj[0] = args;
38583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38584 if (!SWIG_IsOK(res1)) {
38585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38586 }
38587 arg1 = reinterpret_cast< wxWindow * >(argp1);
38588 {
38589 PyThreadState* __tstate = wxPyBeginAllowThreads();
38590 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38591 wxPyEndAllowThreads(__tstate);
38592 if (PyErr_Occurred()) SWIG_fail;
38593 }
38594 {
38595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38596 }
38597 return resultobj;
38598 fail:
38599 return NULL;
38600 }
38601
38602
38603 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38604 PyObject *resultobj = 0;
38605 wxWindow *arg1 = (wxWindow *) 0 ;
38606 bool result;
38607 void *argp1 = 0 ;
38608 int res1 = 0 ;
38609 PyObject *swig_obj[1] ;
38610
38611 if (!args) SWIG_fail;
38612 swig_obj[0] = args;
38613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38616 }
38617 arg1 = reinterpret_cast< wxWindow * >(argp1);
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (bool)(arg1)->Layout();
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 {
38625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38626 }
38627 return resultobj;
38628 fail:
38629 return NULL;
38630 }
38631
38632
38633 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38634 PyObject *resultobj = 0;
38635 wxWindow *arg1 = (wxWindow *) 0 ;
38636 wxSizer *arg2 = (wxSizer *) 0 ;
38637 bool arg3 = (bool) true ;
38638 void *argp1 = 0 ;
38639 int res1 = 0 ;
38640 int res2 = 0 ;
38641 bool val3 ;
38642 int ecode3 = 0 ;
38643 PyObject * obj0 = 0 ;
38644 PyObject * obj1 = 0 ;
38645 PyObject * obj2 = 0 ;
38646 char * kwnames[] = {
38647 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38648 };
38649
38650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38652 if (!SWIG_IsOK(res1)) {
38653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38654 }
38655 arg1 = reinterpret_cast< wxWindow * >(argp1);
38656 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38657 if (!SWIG_IsOK(res2)) {
38658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38659 }
38660 if (obj2) {
38661 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38662 if (!SWIG_IsOK(ecode3)) {
38663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38664 }
38665 arg3 = static_cast< bool >(val3);
38666 }
38667 {
38668 PyThreadState* __tstate = wxPyBeginAllowThreads();
38669 (arg1)->SetSizer(arg2,arg3);
38670 wxPyEndAllowThreads(__tstate);
38671 if (PyErr_Occurred()) SWIG_fail;
38672 }
38673 resultobj = SWIG_Py_Void();
38674 return resultobj;
38675 fail:
38676 return NULL;
38677 }
38678
38679
38680 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38681 PyObject *resultobj = 0;
38682 wxWindow *arg1 = (wxWindow *) 0 ;
38683 wxSizer *arg2 = (wxSizer *) 0 ;
38684 bool arg3 = (bool) true ;
38685 void *argp1 = 0 ;
38686 int res1 = 0 ;
38687 int res2 = 0 ;
38688 bool val3 ;
38689 int ecode3 = 0 ;
38690 PyObject * obj0 = 0 ;
38691 PyObject * obj1 = 0 ;
38692 PyObject * obj2 = 0 ;
38693 char * kwnames[] = {
38694 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38695 };
38696
38697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38699 if (!SWIG_IsOK(res1)) {
38700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38701 }
38702 arg1 = reinterpret_cast< wxWindow * >(argp1);
38703 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38704 if (!SWIG_IsOK(res2)) {
38705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38706 }
38707 if (obj2) {
38708 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38709 if (!SWIG_IsOK(ecode3)) {
38710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38711 }
38712 arg3 = static_cast< bool >(val3);
38713 }
38714 {
38715 PyThreadState* __tstate = wxPyBeginAllowThreads();
38716 (arg1)->SetSizerAndFit(arg2,arg3);
38717 wxPyEndAllowThreads(__tstate);
38718 if (PyErr_Occurred()) SWIG_fail;
38719 }
38720 resultobj = SWIG_Py_Void();
38721 return resultobj;
38722 fail:
38723 return NULL;
38724 }
38725
38726
38727 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38728 PyObject *resultobj = 0;
38729 wxWindow *arg1 = (wxWindow *) 0 ;
38730 wxSizer *result = 0 ;
38731 void *argp1 = 0 ;
38732 int res1 = 0 ;
38733 PyObject *swig_obj[1] ;
38734
38735 if (!args) SWIG_fail;
38736 swig_obj[0] = args;
38737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38738 if (!SWIG_IsOK(res1)) {
38739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38740 }
38741 arg1 = reinterpret_cast< wxWindow * >(argp1);
38742 {
38743 PyThreadState* __tstate = wxPyBeginAllowThreads();
38744 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38745 wxPyEndAllowThreads(__tstate);
38746 if (PyErr_Occurred()) SWIG_fail;
38747 }
38748 {
38749 resultobj = wxPyMake_wxObject(result, (bool)0);
38750 }
38751 return resultobj;
38752 fail:
38753 return NULL;
38754 }
38755
38756
38757 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38758 PyObject *resultobj = 0;
38759 wxWindow *arg1 = (wxWindow *) 0 ;
38760 wxSizer *arg2 = (wxSizer *) 0 ;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 void *argp2 = 0 ;
38764 int res2 = 0 ;
38765 PyObject * obj0 = 0 ;
38766 PyObject * obj1 = 0 ;
38767 char * kwnames[] = {
38768 (char *) "self",(char *) "sizer", NULL
38769 };
38770
38771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38773 if (!SWIG_IsOK(res1)) {
38774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38775 }
38776 arg1 = reinterpret_cast< wxWindow * >(argp1);
38777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38778 if (!SWIG_IsOK(res2)) {
38779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38780 }
38781 arg2 = reinterpret_cast< wxSizer * >(argp2);
38782 {
38783 PyThreadState* __tstate = wxPyBeginAllowThreads();
38784 (arg1)->SetContainingSizer(arg2);
38785 wxPyEndAllowThreads(__tstate);
38786 if (PyErr_Occurred()) SWIG_fail;
38787 }
38788 resultobj = SWIG_Py_Void();
38789 return resultobj;
38790 fail:
38791 return NULL;
38792 }
38793
38794
38795 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38796 PyObject *resultobj = 0;
38797 wxWindow *arg1 = (wxWindow *) 0 ;
38798 wxSizer *result = 0 ;
38799 void *argp1 = 0 ;
38800 int res1 = 0 ;
38801 PyObject *swig_obj[1] ;
38802
38803 if (!args) SWIG_fail;
38804 swig_obj[0] = args;
38805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38806 if (!SWIG_IsOK(res1)) {
38807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38808 }
38809 arg1 = reinterpret_cast< wxWindow * >(argp1);
38810 {
38811 PyThreadState* __tstate = wxPyBeginAllowThreads();
38812 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38813 wxPyEndAllowThreads(__tstate);
38814 if (PyErr_Occurred()) SWIG_fail;
38815 }
38816 {
38817 resultobj = wxPyMake_wxObject(result, (bool)0);
38818 }
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38826 PyObject *resultobj = 0;
38827 wxWindow *arg1 = (wxWindow *) 0 ;
38828 void *argp1 = 0 ;
38829 int res1 = 0 ;
38830 PyObject *swig_obj[1] ;
38831
38832 if (!args) SWIG_fail;
38833 swig_obj[0] = args;
38834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38835 if (!SWIG_IsOK(res1)) {
38836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38837 }
38838 arg1 = reinterpret_cast< wxWindow * >(argp1);
38839 {
38840 PyThreadState* __tstate = wxPyBeginAllowThreads();
38841 (arg1)->InheritAttributes();
38842 wxPyEndAllowThreads(__tstate);
38843 if (PyErr_Occurred()) SWIG_fail;
38844 }
38845 resultobj = SWIG_Py_Void();
38846 return resultobj;
38847 fail:
38848 return NULL;
38849 }
38850
38851
38852 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38853 PyObject *resultobj = 0;
38854 wxWindow *arg1 = (wxWindow *) 0 ;
38855 bool result;
38856 void *argp1 = 0 ;
38857 int res1 = 0 ;
38858 PyObject *swig_obj[1] ;
38859
38860 if (!args) SWIG_fail;
38861 swig_obj[0] = args;
38862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38863 if (!SWIG_IsOK(res1)) {
38864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38865 }
38866 arg1 = reinterpret_cast< wxWindow * >(argp1);
38867 {
38868 PyThreadState* __tstate = wxPyBeginAllowThreads();
38869 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38870 wxPyEndAllowThreads(__tstate);
38871 if (PyErr_Occurred()) SWIG_fail;
38872 }
38873 {
38874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38875 }
38876 return resultobj;
38877 fail:
38878 return NULL;
38879 }
38880
38881
38882 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38883 PyObject *resultobj = 0;
38884 wxWindow *arg1 = (wxWindow *) 0 ;
38885 bool result;
38886 void *argp1 = 0 ;
38887 int res1 = 0 ;
38888 PyObject *swig_obj[1] ;
38889
38890 if (!args) SWIG_fail;
38891 swig_obj[0] = args;
38892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38893 if (!SWIG_IsOK(res1)) {
38894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38895 }
38896 arg1 = reinterpret_cast< wxWindow * >(argp1);
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 result = (bool)(arg1)->CanSetTransparent();
38900 wxPyEndAllowThreads(__tstate);
38901 if (PyErr_Occurred()) SWIG_fail;
38902 }
38903 {
38904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38905 }
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38913 PyObject *resultobj = 0;
38914 wxWindow *arg1 = (wxWindow *) 0 ;
38915 byte arg2 ;
38916 bool result;
38917 void *argp1 = 0 ;
38918 int res1 = 0 ;
38919 unsigned char val2 ;
38920 int ecode2 = 0 ;
38921 PyObject * obj0 = 0 ;
38922 PyObject * obj1 = 0 ;
38923 char * kwnames[] = {
38924 (char *) "self",(char *) "alpha", NULL
38925 };
38926
38927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38929 if (!SWIG_IsOK(res1)) {
38930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38931 }
38932 arg1 = reinterpret_cast< wxWindow * >(argp1);
38933 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38934 if (!SWIG_IsOK(ecode2)) {
38935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38936 }
38937 arg2 = static_cast< byte >(val2);
38938 {
38939 PyThreadState* __tstate = wxPyBeginAllowThreads();
38940 result = (bool)(arg1)->SetTransparent(arg2);
38941 wxPyEndAllowThreads(__tstate);
38942 if (PyErr_Occurred()) SWIG_fail;
38943 }
38944 {
38945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38946 }
38947 return resultobj;
38948 fail:
38949 return NULL;
38950 }
38951
38952
38953 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38954 PyObject *obj;
38955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38956 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38957 return SWIG_Py_Void();
38958 }
38959
38960 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38961 return SWIG_Python_InitShadowInstance(args);
38962 }
38963
38964 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj = 0;
38966 long arg1 ;
38967 wxWindow *arg2 = (wxWindow *) NULL ;
38968 wxWindow *result = 0 ;
38969 long val1 ;
38970 int ecode1 = 0 ;
38971 void *argp2 = 0 ;
38972 int res2 = 0 ;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char * kwnames[] = {
38976 (char *) "id",(char *) "parent", NULL
38977 };
38978
38979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38980 ecode1 = SWIG_AsVal_long(obj0, &val1);
38981 if (!SWIG_IsOK(ecode1)) {
38982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38983 }
38984 arg1 = static_cast< long >(val1);
38985 if (obj1) {
38986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38987 if (!SWIG_IsOK(res2)) {
38988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38989 }
38990 arg2 = reinterpret_cast< wxWindow * >(argp2);
38991 }
38992 {
38993 if (!wxPyCheckForApp()) SWIG_fail;
38994 PyThreadState* __tstate = wxPyBeginAllowThreads();
38995 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38996 wxPyEndAllowThreads(__tstate);
38997 if (PyErr_Occurred()) SWIG_fail;
38998 }
38999 {
39000 resultobj = wxPyMake_wxObject(result, 0);
39001 }
39002 return resultobj;
39003 fail:
39004 return NULL;
39005 }
39006
39007
39008 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj = 0;
39010 wxString *arg1 = 0 ;
39011 wxWindow *arg2 = (wxWindow *) NULL ;
39012 wxWindow *result = 0 ;
39013 bool temp1 = false ;
39014 void *argp2 = 0 ;
39015 int res2 = 0 ;
39016 PyObject * obj0 = 0 ;
39017 PyObject * obj1 = 0 ;
39018 char * kwnames[] = {
39019 (char *) "name",(char *) "parent", NULL
39020 };
39021
39022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39023 {
39024 arg1 = wxString_in_helper(obj0);
39025 if (arg1 == NULL) SWIG_fail;
39026 temp1 = true;
39027 }
39028 if (obj1) {
39029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39030 if (!SWIG_IsOK(res2)) {
39031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39032 }
39033 arg2 = reinterpret_cast< wxWindow * >(argp2);
39034 }
39035 {
39036 if (!wxPyCheckForApp()) SWIG_fail;
39037 PyThreadState* __tstate = wxPyBeginAllowThreads();
39038 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39039 wxPyEndAllowThreads(__tstate);
39040 if (PyErr_Occurred()) SWIG_fail;
39041 }
39042 {
39043 resultobj = wxPyMake_wxObject(result, 0);
39044 }
39045 {
39046 if (temp1)
39047 delete arg1;
39048 }
39049 return resultobj;
39050 fail:
39051 {
39052 if (temp1)
39053 delete arg1;
39054 }
39055 return NULL;
39056 }
39057
39058
39059 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39060 PyObject *resultobj = 0;
39061 wxString *arg1 = 0 ;
39062 wxWindow *arg2 = (wxWindow *) NULL ;
39063 wxWindow *result = 0 ;
39064 bool temp1 = false ;
39065 void *argp2 = 0 ;
39066 int res2 = 0 ;
39067 PyObject * obj0 = 0 ;
39068 PyObject * obj1 = 0 ;
39069 char * kwnames[] = {
39070 (char *) "label",(char *) "parent", NULL
39071 };
39072
39073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39074 {
39075 arg1 = wxString_in_helper(obj0);
39076 if (arg1 == NULL) SWIG_fail;
39077 temp1 = true;
39078 }
39079 if (obj1) {
39080 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39081 if (!SWIG_IsOK(res2)) {
39082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39083 }
39084 arg2 = reinterpret_cast< wxWindow * >(argp2);
39085 }
39086 {
39087 if (!wxPyCheckForApp()) SWIG_fail;
39088 PyThreadState* __tstate = wxPyBeginAllowThreads();
39089 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39090 wxPyEndAllowThreads(__tstate);
39091 if (PyErr_Occurred()) SWIG_fail;
39092 }
39093 {
39094 resultobj = wxPyMake_wxObject(result, 0);
39095 }
39096 {
39097 if (temp1)
39098 delete arg1;
39099 }
39100 return resultobj;
39101 fail:
39102 {
39103 if (temp1)
39104 delete arg1;
39105 }
39106 return NULL;
39107 }
39108
39109
39110 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39111 PyObject *resultobj = 0;
39112 wxWindow *arg1 = (wxWindow *) 0 ;
39113 unsigned long arg2 ;
39114 wxWindow *result = 0 ;
39115 void *argp1 = 0 ;
39116 int res1 = 0 ;
39117 unsigned long val2 ;
39118 int ecode2 = 0 ;
39119 PyObject * obj0 = 0 ;
39120 PyObject * obj1 = 0 ;
39121 char * kwnames[] = {
39122 (char *) "parent",(char *) "_hWnd", NULL
39123 };
39124
39125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39127 if (!SWIG_IsOK(res1)) {
39128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39129 }
39130 arg1 = reinterpret_cast< wxWindow * >(argp1);
39131 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39132 if (!SWIG_IsOK(ecode2)) {
39133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39134 }
39135 arg2 = static_cast< unsigned long >(val2);
39136 {
39137 PyThreadState* __tstate = wxPyBeginAllowThreads();
39138 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39139 wxPyEndAllowThreads(__tstate);
39140 if (PyErr_Occurred()) SWIG_fail;
39141 }
39142 {
39143 resultobj = wxPyMake_wxObject(result, 0);
39144 }
39145 return resultobj;
39146 fail:
39147 return NULL;
39148 }
39149
39150
39151 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39152 PyObject *resultobj = 0;
39153 PyObject *result = 0 ;
39154
39155 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39156 {
39157 PyThreadState* __tstate = wxPyBeginAllowThreads();
39158 result = (PyObject *)GetTopLevelWindows();
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 resultobj = result;
39163 return resultobj;
39164 fail:
39165 return NULL;
39166 }
39167
39168
39169 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39170 PyObject *resultobj = 0;
39171 wxValidator *result = 0 ;
39172
39173 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39174 {
39175 PyThreadState* __tstate = wxPyBeginAllowThreads();
39176 result = (wxValidator *)new wxValidator();
39177 wxPyEndAllowThreads(__tstate);
39178 if (PyErr_Occurred()) SWIG_fail;
39179 }
39180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39181 return resultobj;
39182 fail:
39183 return NULL;
39184 }
39185
39186
39187 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39188 PyObject *resultobj = 0;
39189 wxValidator *arg1 = (wxValidator *) 0 ;
39190 wxValidator *result = 0 ;
39191 void *argp1 = 0 ;
39192 int res1 = 0 ;
39193 PyObject *swig_obj[1] ;
39194
39195 if (!args) SWIG_fail;
39196 swig_obj[0] = args;
39197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39198 if (!SWIG_IsOK(res1)) {
39199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39200 }
39201 arg1 = reinterpret_cast< wxValidator * >(argp1);
39202 {
39203 PyThreadState* __tstate = wxPyBeginAllowThreads();
39204 result = (wxValidator *)(arg1)->Clone();
39205 wxPyEndAllowThreads(__tstate);
39206 if (PyErr_Occurred()) SWIG_fail;
39207 }
39208 {
39209 resultobj = wxPyMake_wxObject(result, 0);
39210 }
39211 return resultobj;
39212 fail:
39213 return NULL;
39214 }
39215
39216
39217 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39218 PyObject *resultobj = 0;
39219 wxValidator *arg1 = (wxValidator *) 0 ;
39220 wxWindow *arg2 = (wxWindow *) 0 ;
39221 bool result;
39222 void *argp1 = 0 ;
39223 int res1 = 0 ;
39224 void *argp2 = 0 ;
39225 int res2 = 0 ;
39226 PyObject * obj0 = 0 ;
39227 PyObject * obj1 = 0 ;
39228 char * kwnames[] = {
39229 (char *) "self",(char *) "parent", NULL
39230 };
39231
39232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39234 if (!SWIG_IsOK(res1)) {
39235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39236 }
39237 arg1 = reinterpret_cast< wxValidator * >(argp1);
39238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39239 if (!SWIG_IsOK(res2)) {
39240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39241 }
39242 arg2 = reinterpret_cast< wxWindow * >(argp2);
39243 {
39244 PyThreadState* __tstate = wxPyBeginAllowThreads();
39245 result = (bool)(arg1)->Validate(arg2);
39246 wxPyEndAllowThreads(__tstate);
39247 if (PyErr_Occurred()) SWIG_fail;
39248 }
39249 {
39250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39251 }
39252 return resultobj;
39253 fail:
39254 return NULL;
39255 }
39256
39257
39258 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39259 PyObject *resultobj = 0;
39260 wxValidator *arg1 = (wxValidator *) 0 ;
39261 bool result;
39262 void *argp1 = 0 ;
39263 int res1 = 0 ;
39264 PyObject *swig_obj[1] ;
39265
39266 if (!args) SWIG_fail;
39267 swig_obj[0] = args;
39268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39269 if (!SWIG_IsOK(res1)) {
39270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39271 }
39272 arg1 = reinterpret_cast< wxValidator * >(argp1);
39273 {
39274 PyThreadState* __tstate = wxPyBeginAllowThreads();
39275 result = (bool)(arg1)->TransferToWindow();
39276 wxPyEndAllowThreads(__tstate);
39277 if (PyErr_Occurred()) SWIG_fail;
39278 }
39279 {
39280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39281 }
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39289 PyObject *resultobj = 0;
39290 wxValidator *arg1 = (wxValidator *) 0 ;
39291 bool result;
39292 void *argp1 = 0 ;
39293 int res1 = 0 ;
39294 PyObject *swig_obj[1] ;
39295
39296 if (!args) SWIG_fail;
39297 swig_obj[0] = args;
39298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39299 if (!SWIG_IsOK(res1)) {
39300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39301 }
39302 arg1 = reinterpret_cast< wxValidator * >(argp1);
39303 {
39304 PyThreadState* __tstate = wxPyBeginAllowThreads();
39305 result = (bool)(arg1)->TransferFromWindow();
39306 wxPyEndAllowThreads(__tstate);
39307 if (PyErr_Occurred()) SWIG_fail;
39308 }
39309 {
39310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39311 }
39312 return resultobj;
39313 fail:
39314 return NULL;
39315 }
39316
39317
39318 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39319 PyObject *resultobj = 0;
39320 wxValidator *arg1 = (wxValidator *) 0 ;
39321 wxWindow *result = 0 ;
39322 void *argp1 = 0 ;
39323 int res1 = 0 ;
39324 PyObject *swig_obj[1] ;
39325
39326 if (!args) SWIG_fail;
39327 swig_obj[0] = args;
39328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39329 if (!SWIG_IsOK(res1)) {
39330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39331 }
39332 arg1 = reinterpret_cast< wxValidator * >(argp1);
39333 {
39334 PyThreadState* __tstate = wxPyBeginAllowThreads();
39335 result = (wxWindow *)(arg1)->GetWindow();
39336 wxPyEndAllowThreads(__tstate);
39337 if (PyErr_Occurred()) SWIG_fail;
39338 }
39339 {
39340 resultobj = wxPyMake_wxObject(result, 0);
39341 }
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39349 PyObject *resultobj = 0;
39350 wxValidator *arg1 = (wxValidator *) 0 ;
39351 wxWindow *arg2 = (wxWindow *) 0 ;
39352 void *argp1 = 0 ;
39353 int res1 = 0 ;
39354 void *argp2 = 0 ;
39355 int res2 = 0 ;
39356 PyObject * obj0 = 0 ;
39357 PyObject * obj1 = 0 ;
39358 char * kwnames[] = {
39359 (char *) "self",(char *) "window", NULL
39360 };
39361
39362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39364 if (!SWIG_IsOK(res1)) {
39365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39366 }
39367 arg1 = reinterpret_cast< wxValidator * >(argp1);
39368 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39369 if (!SWIG_IsOK(res2)) {
39370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39371 }
39372 arg2 = reinterpret_cast< wxWindow * >(argp2);
39373 {
39374 PyThreadState* __tstate = wxPyBeginAllowThreads();
39375 (arg1)->SetWindow(arg2);
39376 wxPyEndAllowThreads(__tstate);
39377 if (PyErr_Occurred()) SWIG_fail;
39378 }
39379 resultobj = SWIG_Py_Void();
39380 return resultobj;
39381 fail:
39382 return NULL;
39383 }
39384
39385
39386 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39387 PyObject *resultobj = 0;
39388 bool result;
39389
39390 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39391 {
39392 PyThreadState* __tstate = wxPyBeginAllowThreads();
39393 result = (bool)wxValidator::IsSilent();
39394 wxPyEndAllowThreads(__tstate);
39395 if (PyErr_Occurred()) SWIG_fail;
39396 }
39397 {
39398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39399 }
39400 return resultobj;
39401 fail:
39402 return NULL;
39403 }
39404
39405
39406 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39407 PyObject *resultobj = 0;
39408 int arg1 = (int) true ;
39409 int val1 ;
39410 int ecode1 = 0 ;
39411 PyObject * obj0 = 0 ;
39412 char * kwnames[] = {
39413 (char *) "doIt", NULL
39414 };
39415
39416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39417 if (obj0) {
39418 ecode1 = SWIG_AsVal_int(obj0, &val1);
39419 if (!SWIG_IsOK(ecode1)) {
39420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39421 }
39422 arg1 = static_cast< int >(val1);
39423 }
39424 {
39425 PyThreadState* __tstate = wxPyBeginAllowThreads();
39426 wxValidator::SetBellOnError(arg1);
39427 wxPyEndAllowThreads(__tstate);
39428 if (PyErr_Occurred()) SWIG_fail;
39429 }
39430 resultobj = SWIG_Py_Void();
39431 return resultobj;
39432 fail:
39433 return NULL;
39434 }
39435
39436
39437 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39438 PyObject *obj;
39439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39440 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39441 return SWIG_Py_Void();
39442 }
39443
39444 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39445 return SWIG_Python_InitShadowInstance(args);
39446 }
39447
39448 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39449 PyObject *resultobj = 0;
39450 wxPyValidator *result = 0 ;
39451
39452 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39453 {
39454 PyThreadState* __tstate = wxPyBeginAllowThreads();
39455 result = (wxPyValidator *)new wxPyValidator();
39456 wxPyEndAllowThreads(__tstate);
39457 if (PyErr_Occurred()) SWIG_fail;
39458 }
39459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39460 return resultobj;
39461 fail:
39462 return NULL;
39463 }
39464
39465
39466 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39467 PyObject *resultobj = 0;
39468 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39469 PyObject *arg2 = (PyObject *) 0 ;
39470 PyObject *arg3 = (PyObject *) 0 ;
39471 int arg4 = (int) true ;
39472 void *argp1 = 0 ;
39473 int res1 = 0 ;
39474 int val4 ;
39475 int ecode4 = 0 ;
39476 PyObject * obj0 = 0 ;
39477 PyObject * obj1 = 0 ;
39478 PyObject * obj2 = 0 ;
39479 PyObject * obj3 = 0 ;
39480 char * kwnames[] = {
39481 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39482 };
39483
39484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39486 if (!SWIG_IsOK(res1)) {
39487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39488 }
39489 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39490 arg2 = obj1;
39491 arg3 = obj2;
39492 if (obj3) {
39493 ecode4 = SWIG_AsVal_int(obj3, &val4);
39494 if (!SWIG_IsOK(ecode4)) {
39495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39496 }
39497 arg4 = static_cast< int >(val4);
39498 }
39499 {
39500 PyThreadState* __tstate = wxPyBeginAllowThreads();
39501 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39502 wxPyEndAllowThreads(__tstate);
39503 if (PyErr_Occurred()) SWIG_fail;
39504 }
39505 resultobj = SWIG_Py_Void();
39506 return resultobj;
39507 fail:
39508 return NULL;
39509 }
39510
39511
39512 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39513 PyObject *obj;
39514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39515 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39516 return SWIG_Py_Void();
39517 }
39518
39519 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39520 return SWIG_Python_InitShadowInstance(args);
39521 }
39522
39523 SWIGINTERN int DefaultValidator_set(PyObject *) {
39524 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39525 return 1;
39526 }
39527
39528
39529 SWIGINTERN PyObject *DefaultValidator_get(void) {
39530 PyObject *pyobj = 0;
39531
39532 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39533 return pyobj;
39534 }
39535
39536
39537 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39538 PyObject *resultobj = 0;
39539 wxString const &arg1_defvalue = wxPyEmptyString ;
39540 wxString *arg1 = (wxString *) &arg1_defvalue ;
39541 long arg2 = (long) 0 ;
39542 wxMenu *result = 0 ;
39543 bool temp1 = false ;
39544 long val2 ;
39545 int ecode2 = 0 ;
39546 PyObject * obj0 = 0 ;
39547 PyObject * obj1 = 0 ;
39548 char * kwnames[] = {
39549 (char *) "title",(char *) "style", NULL
39550 };
39551
39552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39553 if (obj0) {
39554 {
39555 arg1 = wxString_in_helper(obj0);
39556 if (arg1 == NULL) SWIG_fail;
39557 temp1 = true;
39558 }
39559 }
39560 if (obj1) {
39561 ecode2 = SWIG_AsVal_long(obj1, &val2);
39562 if (!SWIG_IsOK(ecode2)) {
39563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39564 }
39565 arg2 = static_cast< long >(val2);
39566 }
39567 {
39568 if (!wxPyCheckForApp()) SWIG_fail;
39569 PyThreadState* __tstate = wxPyBeginAllowThreads();
39570 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39571 wxPyEndAllowThreads(__tstate);
39572 if (PyErr_Occurred()) SWIG_fail;
39573 }
39574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39575 {
39576 if (temp1)
39577 delete arg1;
39578 }
39579 return resultobj;
39580 fail:
39581 {
39582 if (temp1)
39583 delete arg1;
39584 }
39585 return NULL;
39586 }
39587
39588
39589 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39590 PyObject *resultobj = 0;
39591 wxMenu *arg1 = (wxMenu *) 0 ;
39592 int arg2 ;
39593 wxString const &arg3_defvalue = wxPyEmptyString ;
39594 wxString *arg3 = (wxString *) &arg3_defvalue ;
39595 wxString const &arg4_defvalue = wxPyEmptyString ;
39596 wxString *arg4 = (wxString *) &arg4_defvalue ;
39597 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39598 wxMenuItem *result = 0 ;
39599 void *argp1 = 0 ;
39600 int res1 = 0 ;
39601 int val2 ;
39602 int ecode2 = 0 ;
39603 bool temp3 = false ;
39604 bool temp4 = false ;
39605 int val5 ;
39606 int ecode5 = 0 ;
39607 PyObject * obj0 = 0 ;
39608 PyObject * obj1 = 0 ;
39609 PyObject * obj2 = 0 ;
39610 PyObject * obj3 = 0 ;
39611 PyObject * obj4 = 0 ;
39612 char * kwnames[] = {
39613 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39614 };
39615
39616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39618 if (!SWIG_IsOK(res1)) {
39619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39620 }
39621 arg1 = reinterpret_cast< wxMenu * >(argp1);
39622 ecode2 = SWIG_AsVal_int(obj1, &val2);
39623 if (!SWIG_IsOK(ecode2)) {
39624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39625 }
39626 arg2 = static_cast< int >(val2);
39627 if (obj2) {
39628 {
39629 arg3 = wxString_in_helper(obj2);
39630 if (arg3 == NULL) SWIG_fail;
39631 temp3 = true;
39632 }
39633 }
39634 if (obj3) {
39635 {
39636 arg4 = wxString_in_helper(obj3);
39637 if (arg4 == NULL) SWIG_fail;
39638 temp4 = true;
39639 }
39640 }
39641 if (obj4) {
39642 ecode5 = SWIG_AsVal_int(obj4, &val5);
39643 if (!SWIG_IsOK(ecode5)) {
39644 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39645 }
39646 arg5 = static_cast< wxItemKind >(val5);
39647 }
39648 {
39649 PyThreadState* __tstate = wxPyBeginAllowThreads();
39650 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39651 wxPyEndAllowThreads(__tstate);
39652 if (PyErr_Occurred()) SWIG_fail;
39653 }
39654 {
39655 resultobj = wxPyMake_wxObject(result, (bool)0);
39656 }
39657 {
39658 if (temp3)
39659 delete arg3;
39660 }
39661 {
39662 if (temp4)
39663 delete arg4;
39664 }
39665 return resultobj;
39666 fail:
39667 {
39668 if (temp3)
39669 delete arg3;
39670 }
39671 {
39672 if (temp4)
39673 delete arg4;
39674 }
39675 return NULL;
39676 }
39677
39678
39679 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39680 PyObject *resultobj = 0;
39681 wxMenu *arg1 = (wxMenu *) 0 ;
39682 wxMenuItem *result = 0 ;
39683 void *argp1 = 0 ;
39684 int res1 = 0 ;
39685 PyObject *swig_obj[1] ;
39686
39687 if (!args) SWIG_fail;
39688 swig_obj[0] = args;
39689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39690 if (!SWIG_IsOK(res1)) {
39691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39692 }
39693 arg1 = reinterpret_cast< wxMenu * >(argp1);
39694 {
39695 PyThreadState* __tstate = wxPyBeginAllowThreads();
39696 result = (wxMenuItem *)(arg1)->AppendSeparator();
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 {
39701 resultobj = wxPyMake_wxObject(result, (bool)0);
39702 }
39703 return resultobj;
39704 fail:
39705 return NULL;
39706 }
39707
39708
39709 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39710 PyObject *resultobj = 0;
39711 wxMenu *arg1 = (wxMenu *) 0 ;
39712 int arg2 ;
39713 wxString *arg3 = 0 ;
39714 wxString const &arg4_defvalue = wxPyEmptyString ;
39715 wxString *arg4 = (wxString *) &arg4_defvalue ;
39716 wxMenuItem *result = 0 ;
39717 void *argp1 = 0 ;
39718 int res1 = 0 ;
39719 int val2 ;
39720 int ecode2 = 0 ;
39721 bool temp3 = false ;
39722 bool temp4 = false ;
39723 PyObject * obj0 = 0 ;
39724 PyObject * obj1 = 0 ;
39725 PyObject * obj2 = 0 ;
39726 PyObject * obj3 = 0 ;
39727 char * kwnames[] = {
39728 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39729 };
39730
39731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39733 if (!SWIG_IsOK(res1)) {
39734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39735 }
39736 arg1 = reinterpret_cast< wxMenu * >(argp1);
39737 ecode2 = SWIG_AsVal_int(obj1, &val2);
39738 if (!SWIG_IsOK(ecode2)) {
39739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39740 }
39741 arg2 = static_cast< int >(val2);
39742 {
39743 arg3 = wxString_in_helper(obj2);
39744 if (arg3 == NULL) SWIG_fail;
39745 temp3 = true;
39746 }
39747 if (obj3) {
39748 {
39749 arg4 = wxString_in_helper(obj3);
39750 if (arg4 == NULL) SWIG_fail;
39751 temp4 = true;
39752 }
39753 }
39754 {
39755 PyThreadState* __tstate = wxPyBeginAllowThreads();
39756 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39757 wxPyEndAllowThreads(__tstate);
39758 if (PyErr_Occurred()) SWIG_fail;
39759 }
39760 {
39761 resultobj = wxPyMake_wxObject(result, (bool)0);
39762 }
39763 {
39764 if (temp3)
39765 delete arg3;
39766 }
39767 {
39768 if (temp4)
39769 delete arg4;
39770 }
39771 return resultobj;
39772 fail:
39773 {
39774 if (temp3)
39775 delete arg3;
39776 }
39777 {
39778 if (temp4)
39779 delete arg4;
39780 }
39781 return NULL;
39782 }
39783
39784
39785 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39786 PyObject *resultobj = 0;
39787 wxMenu *arg1 = (wxMenu *) 0 ;
39788 int arg2 ;
39789 wxString *arg3 = 0 ;
39790 wxString const &arg4_defvalue = wxPyEmptyString ;
39791 wxString *arg4 = (wxString *) &arg4_defvalue ;
39792 wxMenuItem *result = 0 ;
39793 void *argp1 = 0 ;
39794 int res1 = 0 ;
39795 int val2 ;
39796 int ecode2 = 0 ;
39797 bool temp3 = false ;
39798 bool temp4 = false ;
39799 PyObject * obj0 = 0 ;
39800 PyObject * obj1 = 0 ;
39801 PyObject * obj2 = 0 ;
39802 PyObject * obj3 = 0 ;
39803 char * kwnames[] = {
39804 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39805 };
39806
39807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39809 if (!SWIG_IsOK(res1)) {
39810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39811 }
39812 arg1 = reinterpret_cast< wxMenu * >(argp1);
39813 ecode2 = SWIG_AsVal_int(obj1, &val2);
39814 if (!SWIG_IsOK(ecode2)) {
39815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39816 }
39817 arg2 = static_cast< int >(val2);
39818 {
39819 arg3 = wxString_in_helper(obj2);
39820 if (arg3 == NULL) SWIG_fail;
39821 temp3 = true;
39822 }
39823 if (obj3) {
39824 {
39825 arg4 = wxString_in_helper(obj3);
39826 if (arg4 == NULL) SWIG_fail;
39827 temp4 = true;
39828 }
39829 }
39830 {
39831 PyThreadState* __tstate = wxPyBeginAllowThreads();
39832 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39833 wxPyEndAllowThreads(__tstate);
39834 if (PyErr_Occurred()) SWIG_fail;
39835 }
39836 {
39837 resultobj = wxPyMake_wxObject(result, (bool)0);
39838 }
39839 {
39840 if (temp3)
39841 delete arg3;
39842 }
39843 {
39844 if (temp4)
39845 delete arg4;
39846 }
39847 return resultobj;
39848 fail:
39849 {
39850 if (temp3)
39851 delete arg3;
39852 }
39853 {
39854 if (temp4)
39855 delete arg4;
39856 }
39857 return NULL;
39858 }
39859
39860
39861 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39862 PyObject *resultobj = 0;
39863 wxMenu *arg1 = (wxMenu *) 0 ;
39864 int arg2 ;
39865 wxString *arg3 = 0 ;
39866 wxMenu *arg4 = (wxMenu *) 0 ;
39867 wxString const &arg5_defvalue = wxPyEmptyString ;
39868 wxString *arg5 = (wxString *) &arg5_defvalue ;
39869 wxMenuItem *result = 0 ;
39870 void *argp1 = 0 ;
39871 int res1 = 0 ;
39872 int val2 ;
39873 int ecode2 = 0 ;
39874 bool temp3 = false ;
39875 void *argp4 = 0 ;
39876 int res4 = 0 ;
39877 bool temp5 = false ;
39878 PyObject * obj0 = 0 ;
39879 PyObject * obj1 = 0 ;
39880 PyObject * obj2 = 0 ;
39881 PyObject * obj3 = 0 ;
39882 PyObject * obj4 = 0 ;
39883 char * kwnames[] = {
39884 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39885 };
39886
39887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39889 if (!SWIG_IsOK(res1)) {
39890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39891 }
39892 arg1 = reinterpret_cast< wxMenu * >(argp1);
39893 ecode2 = SWIG_AsVal_int(obj1, &val2);
39894 if (!SWIG_IsOK(ecode2)) {
39895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39896 }
39897 arg2 = static_cast< int >(val2);
39898 {
39899 arg3 = wxString_in_helper(obj2);
39900 if (arg3 == NULL) SWIG_fail;
39901 temp3 = true;
39902 }
39903 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39904 if (!SWIG_IsOK(res4)) {
39905 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39906 }
39907 arg4 = reinterpret_cast< wxMenu * >(argp4);
39908 if (obj4) {
39909 {
39910 arg5 = wxString_in_helper(obj4);
39911 if (arg5 == NULL) SWIG_fail;
39912 temp5 = true;
39913 }
39914 }
39915 {
39916 PyThreadState* __tstate = wxPyBeginAllowThreads();
39917 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39918 wxPyEndAllowThreads(__tstate);
39919 if (PyErr_Occurred()) SWIG_fail;
39920 }
39921 {
39922 resultobj = wxPyMake_wxObject(result, (bool)0);
39923 }
39924 {
39925 if (temp3)
39926 delete arg3;
39927 }
39928 {
39929 if (temp5)
39930 delete arg5;
39931 }
39932 return resultobj;
39933 fail:
39934 {
39935 if (temp3)
39936 delete arg3;
39937 }
39938 {
39939 if (temp5)
39940 delete arg5;
39941 }
39942 return NULL;
39943 }
39944
39945
39946 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj = 0;
39948 wxMenu *arg1 = (wxMenu *) 0 ;
39949 wxMenu *arg2 = (wxMenu *) 0 ;
39950 wxString *arg3 = 0 ;
39951 wxString const &arg4_defvalue = wxPyEmptyString ;
39952 wxString *arg4 = (wxString *) &arg4_defvalue ;
39953 wxMenuItem *result = 0 ;
39954 void *argp1 = 0 ;
39955 int res1 = 0 ;
39956 void *argp2 = 0 ;
39957 int res2 = 0 ;
39958 bool temp3 = false ;
39959 bool temp4 = false ;
39960 PyObject * obj0 = 0 ;
39961 PyObject * obj1 = 0 ;
39962 PyObject * obj2 = 0 ;
39963 PyObject * obj3 = 0 ;
39964 char * kwnames[] = {
39965 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39966 };
39967
39968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39972 }
39973 arg1 = reinterpret_cast< wxMenu * >(argp1);
39974 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39975 if (!SWIG_IsOK(res2)) {
39976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39977 }
39978 arg2 = reinterpret_cast< wxMenu * >(argp2);
39979 {
39980 arg3 = wxString_in_helper(obj2);
39981 if (arg3 == NULL) SWIG_fail;
39982 temp3 = true;
39983 }
39984 if (obj3) {
39985 {
39986 arg4 = wxString_in_helper(obj3);
39987 if (arg4 == NULL) SWIG_fail;
39988 temp4 = true;
39989 }
39990 }
39991 {
39992 PyThreadState* __tstate = wxPyBeginAllowThreads();
39993 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39994 wxPyEndAllowThreads(__tstate);
39995 if (PyErr_Occurred()) SWIG_fail;
39996 }
39997 {
39998 resultobj = wxPyMake_wxObject(result, (bool)0);
39999 }
40000 {
40001 if (temp3)
40002 delete arg3;
40003 }
40004 {
40005 if (temp4)
40006 delete arg4;
40007 }
40008 return resultobj;
40009 fail:
40010 {
40011 if (temp3)
40012 delete arg3;
40013 }
40014 {
40015 if (temp4)
40016 delete arg4;
40017 }
40018 return NULL;
40019 }
40020
40021
40022 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40023 PyObject *resultobj = 0;
40024 wxMenu *arg1 = (wxMenu *) 0 ;
40025 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40026 wxMenuItem *result = 0 ;
40027 void *argp1 = 0 ;
40028 int res1 = 0 ;
40029 int res2 = 0 ;
40030 PyObject * obj0 = 0 ;
40031 PyObject * obj1 = 0 ;
40032 char * kwnames[] = {
40033 (char *) "self",(char *) "item", NULL
40034 };
40035
40036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40038 if (!SWIG_IsOK(res1)) {
40039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40040 }
40041 arg1 = reinterpret_cast< wxMenu * >(argp1);
40042 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40043 if (!SWIG_IsOK(res2)) {
40044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40045 }
40046 {
40047 PyThreadState* __tstate = wxPyBeginAllowThreads();
40048 result = (wxMenuItem *)(arg1)->Append(arg2);
40049 wxPyEndAllowThreads(__tstate);
40050 if (PyErr_Occurred()) SWIG_fail;
40051 }
40052 {
40053 resultobj = wxPyMake_wxObject(result, (bool)0);
40054 }
40055 return resultobj;
40056 fail:
40057 return NULL;
40058 }
40059
40060
40061 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40062 PyObject *resultobj = 0;
40063 wxMenu *arg1 = (wxMenu *) 0 ;
40064 size_t arg2 ;
40065 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40066 wxMenuItem *result = 0 ;
40067 void *argp1 = 0 ;
40068 int res1 = 0 ;
40069 size_t val2 ;
40070 int ecode2 = 0 ;
40071 int res3 = 0 ;
40072 PyObject * obj0 = 0 ;
40073 PyObject * obj1 = 0 ;
40074 PyObject * obj2 = 0 ;
40075 char * kwnames[] = {
40076 (char *) "self",(char *) "pos",(char *) "item", NULL
40077 };
40078
40079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40081 if (!SWIG_IsOK(res1)) {
40082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40083 }
40084 arg1 = reinterpret_cast< wxMenu * >(argp1);
40085 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40086 if (!SWIG_IsOK(ecode2)) {
40087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40088 }
40089 arg2 = static_cast< size_t >(val2);
40090 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40091 if (!SWIG_IsOK(res3)) {
40092 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40093 }
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40097 wxPyEndAllowThreads(__tstate);
40098 if (PyErr_Occurred()) SWIG_fail;
40099 }
40100 {
40101 resultobj = wxPyMake_wxObject(result, (bool)0);
40102 }
40103 return resultobj;
40104 fail:
40105 return NULL;
40106 }
40107
40108
40109 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40110 PyObject *resultobj = 0;
40111 wxMenu *arg1 = (wxMenu *) 0 ;
40112 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40113 wxMenuItem *result = 0 ;
40114 void *argp1 = 0 ;
40115 int res1 = 0 ;
40116 int res2 = 0 ;
40117 PyObject * obj0 = 0 ;
40118 PyObject * obj1 = 0 ;
40119 char * kwnames[] = {
40120 (char *) "self",(char *) "item", NULL
40121 };
40122
40123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40125 if (!SWIG_IsOK(res1)) {
40126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40127 }
40128 arg1 = reinterpret_cast< wxMenu * >(argp1);
40129 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40130 if (!SWIG_IsOK(res2)) {
40131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40132 }
40133 {
40134 PyThreadState* __tstate = wxPyBeginAllowThreads();
40135 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40136 wxPyEndAllowThreads(__tstate);
40137 if (PyErr_Occurred()) SWIG_fail;
40138 }
40139 {
40140 resultobj = wxPyMake_wxObject(result, (bool)0);
40141 }
40142 return resultobj;
40143 fail:
40144 return NULL;
40145 }
40146
40147
40148 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40149 PyObject *resultobj = 0;
40150 wxMenu *arg1 = (wxMenu *) 0 ;
40151 void *argp1 = 0 ;
40152 int res1 = 0 ;
40153 PyObject *swig_obj[1] ;
40154
40155 if (!args) SWIG_fail;
40156 swig_obj[0] = args;
40157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40160 }
40161 arg1 = reinterpret_cast< wxMenu * >(argp1);
40162 {
40163 PyThreadState* __tstate = wxPyBeginAllowThreads();
40164 (arg1)->Break();
40165 wxPyEndAllowThreads(__tstate);
40166 if (PyErr_Occurred()) SWIG_fail;
40167 }
40168 resultobj = SWIG_Py_Void();
40169 return resultobj;
40170 fail:
40171 return NULL;
40172 }
40173
40174
40175 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40176 PyObject *resultobj = 0;
40177 wxMenu *arg1 = (wxMenu *) 0 ;
40178 size_t arg2 ;
40179 int arg3 ;
40180 wxString const &arg4_defvalue = wxPyEmptyString ;
40181 wxString *arg4 = (wxString *) &arg4_defvalue ;
40182 wxString const &arg5_defvalue = wxPyEmptyString ;
40183 wxString *arg5 = (wxString *) &arg5_defvalue ;
40184 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40185 wxMenuItem *result = 0 ;
40186 void *argp1 = 0 ;
40187 int res1 = 0 ;
40188 size_t val2 ;
40189 int ecode2 = 0 ;
40190 int val3 ;
40191 int ecode3 = 0 ;
40192 bool temp4 = false ;
40193 bool temp5 = false ;
40194 int val6 ;
40195 int ecode6 = 0 ;
40196 PyObject * obj0 = 0 ;
40197 PyObject * obj1 = 0 ;
40198 PyObject * obj2 = 0 ;
40199 PyObject * obj3 = 0 ;
40200 PyObject * obj4 = 0 ;
40201 PyObject * obj5 = 0 ;
40202 char * kwnames[] = {
40203 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40204 };
40205
40206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40208 if (!SWIG_IsOK(res1)) {
40209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40210 }
40211 arg1 = reinterpret_cast< wxMenu * >(argp1);
40212 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40213 if (!SWIG_IsOK(ecode2)) {
40214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40215 }
40216 arg2 = static_cast< size_t >(val2);
40217 ecode3 = SWIG_AsVal_int(obj2, &val3);
40218 if (!SWIG_IsOK(ecode3)) {
40219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40220 }
40221 arg3 = static_cast< int >(val3);
40222 if (obj3) {
40223 {
40224 arg4 = wxString_in_helper(obj3);
40225 if (arg4 == NULL) SWIG_fail;
40226 temp4 = true;
40227 }
40228 }
40229 if (obj4) {
40230 {
40231 arg5 = wxString_in_helper(obj4);
40232 if (arg5 == NULL) SWIG_fail;
40233 temp5 = true;
40234 }
40235 }
40236 if (obj5) {
40237 ecode6 = SWIG_AsVal_int(obj5, &val6);
40238 if (!SWIG_IsOK(ecode6)) {
40239 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40240 }
40241 arg6 = static_cast< wxItemKind >(val6);
40242 }
40243 {
40244 PyThreadState* __tstate = wxPyBeginAllowThreads();
40245 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40246 wxPyEndAllowThreads(__tstate);
40247 if (PyErr_Occurred()) SWIG_fail;
40248 }
40249 {
40250 resultobj = wxPyMake_wxObject(result, (bool)0);
40251 }
40252 {
40253 if (temp4)
40254 delete arg4;
40255 }
40256 {
40257 if (temp5)
40258 delete arg5;
40259 }
40260 return resultobj;
40261 fail:
40262 {
40263 if (temp4)
40264 delete arg4;
40265 }
40266 {
40267 if (temp5)
40268 delete arg5;
40269 }
40270 return NULL;
40271 }
40272
40273
40274 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40275 PyObject *resultobj = 0;
40276 wxMenu *arg1 = (wxMenu *) 0 ;
40277 size_t arg2 ;
40278 wxMenuItem *result = 0 ;
40279 void *argp1 = 0 ;
40280 int res1 = 0 ;
40281 size_t val2 ;
40282 int ecode2 = 0 ;
40283 PyObject * obj0 = 0 ;
40284 PyObject * obj1 = 0 ;
40285 char * kwnames[] = {
40286 (char *) "self",(char *) "pos", NULL
40287 };
40288
40289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40291 if (!SWIG_IsOK(res1)) {
40292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40293 }
40294 arg1 = reinterpret_cast< wxMenu * >(argp1);
40295 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40296 if (!SWIG_IsOK(ecode2)) {
40297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40298 }
40299 arg2 = static_cast< size_t >(val2);
40300 {
40301 PyThreadState* __tstate = wxPyBeginAllowThreads();
40302 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40303 wxPyEndAllowThreads(__tstate);
40304 if (PyErr_Occurred()) SWIG_fail;
40305 }
40306 {
40307 resultobj = wxPyMake_wxObject(result, (bool)0);
40308 }
40309 return resultobj;
40310 fail:
40311 return NULL;
40312 }
40313
40314
40315 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40316 PyObject *resultobj = 0;
40317 wxMenu *arg1 = (wxMenu *) 0 ;
40318 size_t arg2 ;
40319 int arg3 ;
40320 wxString *arg4 = 0 ;
40321 wxString const &arg5_defvalue = wxPyEmptyString ;
40322 wxString *arg5 = (wxString *) &arg5_defvalue ;
40323 wxMenuItem *result = 0 ;
40324 void *argp1 = 0 ;
40325 int res1 = 0 ;
40326 size_t val2 ;
40327 int ecode2 = 0 ;
40328 int val3 ;
40329 int ecode3 = 0 ;
40330 bool temp4 = false ;
40331 bool temp5 = false ;
40332 PyObject * obj0 = 0 ;
40333 PyObject * obj1 = 0 ;
40334 PyObject * obj2 = 0 ;
40335 PyObject * obj3 = 0 ;
40336 PyObject * obj4 = 0 ;
40337 char * kwnames[] = {
40338 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40339 };
40340
40341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40343 if (!SWIG_IsOK(res1)) {
40344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40345 }
40346 arg1 = reinterpret_cast< wxMenu * >(argp1);
40347 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40348 if (!SWIG_IsOK(ecode2)) {
40349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40350 }
40351 arg2 = static_cast< size_t >(val2);
40352 ecode3 = SWIG_AsVal_int(obj2, &val3);
40353 if (!SWIG_IsOK(ecode3)) {
40354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40355 }
40356 arg3 = static_cast< int >(val3);
40357 {
40358 arg4 = wxString_in_helper(obj3);
40359 if (arg4 == NULL) SWIG_fail;
40360 temp4 = true;
40361 }
40362 if (obj4) {
40363 {
40364 arg5 = wxString_in_helper(obj4);
40365 if (arg5 == NULL) SWIG_fail;
40366 temp5 = true;
40367 }
40368 }
40369 {
40370 PyThreadState* __tstate = wxPyBeginAllowThreads();
40371 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40372 wxPyEndAllowThreads(__tstate);
40373 if (PyErr_Occurred()) SWIG_fail;
40374 }
40375 {
40376 resultobj = wxPyMake_wxObject(result, (bool)0);
40377 }
40378 {
40379 if (temp4)
40380 delete arg4;
40381 }
40382 {
40383 if (temp5)
40384 delete arg5;
40385 }
40386 return resultobj;
40387 fail:
40388 {
40389 if (temp4)
40390 delete arg4;
40391 }
40392 {
40393 if (temp5)
40394 delete arg5;
40395 }
40396 return NULL;
40397 }
40398
40399
40400 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj = 0;
40402 wxMenu *arg1 = (wxMenu *) 0 ;
40403 size_t arg2 ;
40404 int arg3 ;
40405 wxString *arg4 = 0 ;
40406 wxString const &arg5_defvalue = wxPyEmptyString ;
40407 wxString *arg5 = (wxString *) &arg5_defvalue ;
40408 wxMenuItem *result = 0 ;
40409 void *argp1 = 0 ;
40410 int res1 = 0 ;
40411 size_t val2 ;
40412 int ecode2 = 0 ;
40413 int val3 ;
40414 int ecode3 = 0 ;
40415 bool temp4 = false ;
40416 bool temp5 = false ;
40417 PyObject * obj0 = 0 ;
40418 PyObject * obj1 = 0 ;
40419 PyObject * obj2 = 0 ;
40420 PyObject * obj3 = 0 ;
40421 PyObject * obj4 = 0 ;
40422 char * kwnames[] = {
40423 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40424 };
40425
40426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40428 if (!SWIG_IsOK(res1)) {
40429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40430 }
40431 arg1 = reinterpret_cast< wxMenu * >(argp1);
40432 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40433 if (!SWIG_IsOK(ecode2)) {
40434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40435 }
40436 arg2 = static_cast< size_t >(val2);
40437 ecode3 = SWIG_AsVal_int(obj2, &val3);
40438 if (!SWIG_IsOK(ecode3)) {
40439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40440 }
40441 arg3 = static_cast< int >(val3);
40442 {
40443 arg4 = wxString_in_helper(obj3);
40444 if (arg4 == NULL) SWIG_fail;
40445 temp4 = true;
40446 }
40447 if (obj4) {
40448 {
40449 arg5 = wxString_in_helper(obj4);
40450 if (arg5 == NULL) SWIG_fail;
40451 temp5 = true;
40452 }
40453 }
40454 {
40455 PyThreadState* __tstate = wxPyBeginAllowThreads();
40456 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40457 wxPyEndAllowThreads(__tstate);
40458 if (PyErr_Occurred()) SWIG_fail;
40459 }
40460 {
40461 resultobj = wxPyMake_wxObject(result, (bool)0);
40462 }
40463 {
40464 if (temp4)
40465 delete arg4;
40466 }
40467 {
40468 if (temp5)
40469 delete arg5;
40470 }
40471 return resultobj;
40472 fail:
40473 {
40474 if (temp4)
40475 delete arg4;
40476 }
40477 {
40478 if (temp5)
40479 delete arg5;
40480 }
40481 return NULL;
40482 }
40483
40484
40485 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40486 PyObject *resultobj = 0;
40487 wxMenu *arg1 = (wxMenu *) 0 ;
40488 size_t arg2 ;
40489 int arg3 ;
40490 wxString *arg4 = 0 ;
40491 wxMenu *arg5 = (wxMenu *) 0 ;
40492 wxString const &arg6_defvalue = wxPyEmptyString ;
40493 wxString *arg6 = (wxString *) &arg6_defvalue ;
40494 wxMenuItem *result = 0 ;
40495 void *argp1 = 0 ;
40496 int res1 = 0 ;
40497 size_t val2 ;
40498 int ecode2 = 0 ;
40499 int val3 ;
40500 int ecode3 = 0 ;
40501 bool temp4 = false ;
40502 void *argp5 = 0 ;
40503 int res5 = 0 ;
40504 bool temp6 = false ;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 PyObject * obj2 = 0 ;
40508 PyObject * obj3 = 0 ;
40509 PyObject * obj4 = 0 ;
40510 PyObject * obj5 = 0 ;
40511 char * kwnames[] = {
40512 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40513 };
40514
40515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40517 if (!SWIG_IsOK(res1)) {
40518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40519 }
40520 arg1 = reinterpret_cast< wxMenu * >(argp1);
40521 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40522 if (!SWIG_IsOK(ecode2)) {
40523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40524 }
40525 arg2 = static_cast< size_t >(val2);
40526 ecode3 = SWIG_AsVal_int(obj2, &val3);
40527 if (!SWIG_IsOK(ecode3)) {
40528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40529 }
40530 arg3 = static_cast< int >(val3);
40531 {
40532 arg4 = wxString_in_helper(obj3);
40533 if (arg4 == NULL) SWIG_fail;
40534 temp4 = true;
40535 }
40536 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40537 if (!SWIG_IsOK(res5)) {
40538 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40539 }
40540 arg5 = reinterpret_cast< wxMenu * >(argp5);
40541 if (obj5) {
40542 {
40543 arg6 = wxString_in_helper(obj5);
40544 if (arg6 == NULL) SWIG_fail;
40545 temp6 = true;
40546 }
40547 }
40548 {
40549 PyThreadState* __tstate = wxPyBeginAllowThreads();
40550 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 {
40555 resultobj = wxPyMake_wxObject(result, (bool)0);
40556 }
40557 {
40558 if (temp4)
40559 delete arg4;
40560 }
40561 {
40562 if (temp6)
40563 delete arg6;
40564 }
40565 return resultobj;
40566 fail:
40567 {
40568 if (temp4)
40569 delete arg4;
40570 }
40571 {
40572 if (temp6)
40573 delete arg6;
40574 }
40575 return NULL;
40576 }
40577
40578
40579 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40580 PyObject *resultobj = 0;
40581 wxMenu *arg1 = (wxMenu *) 0 ;
40582 int arg2 ;
40583 wxString const &arg3_defvalue = wxPyEmptyString ;
40584 wxString *arg3 = (wxString *) &arg3_defvalue ;
40585 wxString const &arg4_defvalue = wxPyEmptyString ;
40586 wxString *arg4 = (wxString *) &arg4_defvalue ;
40587 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40588 wxMenuItem *result = 0 ;
40589 void *argp1 = 0 ;
40590 int res1 = 0 ;
40591 int val2 ;
40592 int ecode2 = 0 ;
40593 bool temp3 = false ;
40594 bool temp4 = false ;
40595 int val5 ;
40596 int ecode5 = 0 ;
40597 PyObject * obj0 = 0 ;
40598 PyObject * obj1 = 0 ;
40599 PyObject * obj2 = 0 ;
40600 PyObject * obj3 = 0 ;
40601 PyObject * obj4 = 0 ;
40602 char * kwnames[] = {
40603 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40604 };
40605
40606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40608 if (!SWIG_IsOK(res1)) {
40609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40610 }
40611 arg1 = reinterpret_cast< wxMenu * >(argp1);
40612 ecode2 = SWIG_AsVal_int(obj1, &val2);
40613 if (!SWIG_IsOK(ecode2)) {
40614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40615 }
40616 arg2 = static_cast< int >(val2);
40617 if (obj2) {
40618 {
40619 arg3 = wxString_in_helper(obj2);
40620 if (arg3 == NULL) SWIG_fail;
40621 temp3 = true;
40622 }
40623 }
40624 if (obj3) {
40625 {
40626 arg4 = wxString_in_helper(obj3);
40627 if (arg4 == NULL) SWIG_fail;
40628 temp4 = true;
40629 }
40630 }
40631 if (obj4) {
40632 ecode5 = SWIG_AsVal_int(obj4, &val5);
40633 if (!SWIG_IsOK(ecode5)) {
40634 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40635 }
40636 arg5 = static_cast< wxItemKind >(val5);
40637 }
40638 {
40639 PyThreadState* __tstate = wxPyBeginAllowThreads();
40640 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40641 wxPyEndAllowThreads(__tstate);
40642 if (PyErr_Occurred()) SWIG_fail;
40643 }
40644 {
40645 resultobj = wxPyMake_wxObject(result, (bool)0);
40646 }
40647 {
40648 if (temp3)
40649 delete arg3;
40650 }
40651 {
40652 if (temp4)
40653 delete arg4;
40654 }
40655 return resultobj;
40656 fail:
40657 {
40658 if (temp3)
40659 delete arg3;
40660 }
40661 {
40662 if (temp4)
40663 delete arg4;
40664 }
40665 return NULL;
40666 }
40667
40668
40669 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40670 PyObject *resultobj = 0;
40671 wxMenu *arg1 = (wxMenu *) 0 ;
40672 wxMenuItem *result = 0 ;
40673 void *argp1 = 0 ;
40674 int res1 = 0 ;
40675 PyObject *swig_obj[1] ;
40676
40677 if (!args) SWIG_fail;
40678 swig_obj[0] = args;
40679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40680 if (!SWIG_IsOK(res1)) {
40681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40682 }
40683 arg1 = reinterpret_cast< wxMenu * >(argp1);
40684 {
40685 PyThreadState* __tstate = wxPyBeginAllowThreads();
40686 result = (wxMenuItem *)(arg1)->PrependSeparator();
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 {
40691 resultobj = wxPyMake_wxObject(result, (bool)0);
40692 }
40693 return resultobj;
40694 fail:
40695 return NULL;
40696 }
40697
40698
40699 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40700 PyObject *resultobj = 0;
40701 wxMenu *arg1 = (wxMenu *) 0 ;
40702 int arg2 ;
40703 wxString *arg3 = 0 ;
40704 wxString const &arg4_defvalue = wxPyEmptyString ;
40705 wxString *arg4 = (wxString *) &arg4_defvalue ;
40706 wxMenuItem *result = 0 ;
40707 void *argp1 = 0 ;
40708 int res1 = 0 ;
40709 int val2 ;
40710 int ecode2 = 0 ;
40711 bool temp3 = false ;
40712 bool temp4 = false ;
40713 PyObject * obj0 = 0 ;
40714 PyObject * obj1 = 0 ;
40715 PyObject * obj2 = 0 ;
40716 PyObject * obj3 = 0 ;
40717 char * kwnames[] = {
40718 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40719 };
40720
40721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40723 if (!SWIG_IsOK(res1)) {
40724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40725 }
40726 arg1 = reinterpret_cast< wxMenu * >(argp1);
40727 ecode2 = SWIG_AsVal_int(obj1, &val2);
40728 if (!SWIG_IsOK(ecode2)) {
40729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40730 }
40731 arg2 = static_cast< int >(val2);
40732 {
40733 arg3 = wxString_in_helper(obj2);
40734 if (arg3 == NULL) SWIG_fail;
40735 temp3 = true;
40736 }
40737 if (obj3) {
40738 {
40739 arg4 = wxString_in_helper(obj3);
40740 if (arg4 == NULL) SWIG_fail;
40741 temp4 = true;
40742 }
40743 }
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40747 wxPyEndAllowThreads(__tstate);
40748 if (PyErr_Occurred()) SWIG_fail;
40749 }
40750 {
40751 resultobj = wxPyMake_wxObject(result, (bool)0);
40752 }
40753 {
40754 if (temp3)
40755 delete arg3;
40756 }
40757 {
40758 if (temp4)
40759 delete arg4;
40760 }
40761 return resultobj;
40762 fail:
40763 {
40764 if (temp3)
40765 delete arg3;
40766 }
40767 {
40768 if (temp4)
40769 delete arg4;
40770 }
40771 return NULL;
40772 }
40773
40774
40775 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40776 PyObject *resultobj = 0;
40777 wxMenu *arg1 = (wxMenu *) 0 ;
40778 int arg2 ;
40779 wxString *arg3 = 0 ;
40780 wxString const &arg4_defvalue = wxPyEmptyString ;
40781 wxString *arg4 = (wxString *) &arg4_defvalue ;
40782 wxMenuItem *result = 0 ;
40783 void *argp1 = 0 ;
40784 int res1 = 0 ;
40785 int val2 ;
40786 int ecode2 = 0 ;
40787 bool temp3 = false ;
40788 bool temp4 = false ;
40789 PyObject * obj0 = 0 ;
40790 PyObject * obj1 = 0 ;
40791 PyObject * obj2 = 0 ;
40792 PyObject * obj3 = 0 ;
40793 char * kwnames[] = {
40794 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40795 };
40796
40797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40799 if (!SWIG_IsOK(res1)) {
40800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40801 }
40802 arg1 = reinterpret_cast< wxMenu * >(argp1);
40803 ecode2 = SWIG_AsVal_int(obj1, &val2);
40804 if (!SWIG_IsOK(ecode2)) {
40805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40806 }
40807 arg2 = static_cast< int >(val2);
40808 {
40809 arg3 = wxString_in_helper(obj2);
40810 if (arg3 == NULL) SWIG_fail;
40811 temp3 = true;
40812 }
40813 if (obj3) {
40814 {
40815 arg4 = wxString_in_helper(obj3);
40816 if (arg4 == NULL) SWIG_fail;
40817 temp4 = true;
40818 }
40819 }
40820 {
40821 PyThreadState* __tstate = wxPyBeginAllowThreads();
40822 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40823 wxPyEndAllowThreads(__tstate);
40824 if (PyErr_Occurred()) SWIG_fail;
40825 }
40826 {
40827 resultobj = wxPyMake_wxObject(result, (bool)0);
40828 }
40829 {
40830 if (temp3)
40831 delete arg3;
40832 }
40833 {
40834 if (temp4)
40835 delete arg4;
40836 }
40837 return resultobj;
40838 fail:
40839 {
40840 if (temp3)
40841 delete arg3;
40842 }
40843 {
40844 if (temp4)
40845 delete arg4;
40846 }
40847 return NULL;
40848 }
40849
40850
40851 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40852 PyObject *resultobj = 0;
40853 wxMenu *arg1 = (wxMenu *) 0 ;
40854 int arg2 ;
40855 wxString *arg3 = 0 ;
40856 wxMenu *arg4 = (wxMenu *) 0 ;
40857 wxString const &arg5_defvalue = wxPyEmptyString ;
40858 wxString *arg5 = (wxString *) &arg5_defvalue ;
40859 wxMenuItem *result = 0 ;
40860 void *argp1 = 0 ;
40861 int res1 = 0 ;
40862 int val2 ;
40863 int ecode2 = 0 ;
40864 bool temp3 = false ;
40865 void *argp4 = 0 ;
40866 int res4 = 0 ;
40867 bool temp5 = false ;
40868 PyObject * obj0 = 0 ;
40869 PyObject * obj1 = 0 ;
40870 PyObject * obj2 = 0 ;
40871 PyObject * obj3 = 0 ;
40872 PyObject * obj4 = 0 ;
40873 char * kwnames[] = {
40874 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40875 };
40876
40877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40879 if (!SWIG_IsOK(res1)) {
40880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40881 }
40882 arg1 = reinterpret_cast< wxMenu * >(argp1);
40883 ecode2 = SWIG_AsVal_int(obj1, &val2);
40884 if (!SWIG_IsOK(ecode2)) {
40885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40886 }
40887 arg2 = static_cast< int >(val2);
40888 {
40889 arg3 = wxString_in_helper(obj2);
40890 if (arg3 == NULL) SWIG_fail;
40891 temp3 = true;
40892 }
40893 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40894 if (!SWIG_IsOK(res4)) {
40895 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40896 }
40897 arg4 = reinterpret_cast< wxMenu * >(argp4);
40898 if (obj4) {
40899 {
40900 arg5 = wxString_in_helper(obj4);
40901 if (arg5 == NULL) SWIG_fail;
40902 temp5 = true;
40903 }
40904 }
40905 {
40906 PyThreadState* __tstate = wxPyBeginAllowThreads();
40907 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40908 wxPyEndAllowThreads(__tstate);
40909 if (PyErr_Occurred()) SWIG_fail;
40910 }
40911 {
40912 resultobj = wxPyMake_wxObject(result, (bool)0);
40913 }
40914 {
40915 if (temp3)
40916 delete arg3;
40917 }
40918 {
40919 if (temp5)
40920 delete arg5;
40921 }
40922 return resultobj;
40923 fail:
40924 {
40925 if (temp3)
40926 delete arg3;
40927 }
40928 {
40929 if (temp5)
40930 delete arg5;
40931 }
40932 return NULL;
40933 }
40934
40935
40936 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40937 PyObject *resultobj = 0;
40938 wxMenu *arg1 = (wxMenu *) 0 ;
40939 int arg2 ;
40940 wxMenuItem *result = 0 ;
40941 void *argp1 = 0 ;
40942 int res1 = 0 ;
40943 int val2 ;
40944 int ecode2 = 0 ;
40945 PyObject * obj0 = 0 ;
40946 PyObject * obj1 = 0 ;
40947 char * kwnames[] = {
40948 (char *) "self",(char *) "id", NULL
40949 };
40950
40951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40953 if (!SWIG_IsOK(res1)) {
40954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40955 }
40956 arg1 = reinterpret_cast< wxMenu * >(argp1);
40957 ecode2 = SWIG_AsVal_int(obj1, &val2);
40958 if (!SWIG_IsOK(ecode2)) {
40959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40960 }
40961 arg2 = static_cast< int >(val2);
40962 {
40963 PyThreadState* __tstate = wxPyBeginAllowThreads();
40964 result = (wxMenuItem *)(arg1)->Remove(arg2);
40965 wxPyEndAllowThreads(__tstate);
40966 if (PyErr_Occurred()) SWIG_fail;
40967 }
40968 {
40969 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40970 }
40971 return resultobj;
40972 fail:
40973 return NULL;
40974 }
40975
40976
40977 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40978 PyObject *resultobj = 0;
40979 wxMenu *arg1 = (wxMenu *) 0 ;
40980 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40981 wxMenuItem *result = 0 ;
40982 void *argp1 = 0 ;
40983 int res1 = 0 ;
40984 void *argp2 = 0 ;
40985 int res2 = 0 ;
40986 PyObject * obj0 = 0 ;
40987 PyObject * obj1 = 0 ;
40988 char * kwnames[] = {
40989 (char *) "self",(char *) "item", NULL
40990 };
40991
40992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40994 if (!SWIG_IsOK(res1)) {
40995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40996 }
40997 arg1 = reinterpret_cast< wxMenu * >(argp1);
40998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40999 if (!SWIG_IsOK(res2)) {
41000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41001 }
41002 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41003 {
41004 PyThreadState* __tstate = wxPyBeginAllowThreads();
41005 result = (wxMenuItem *)(arg1)->Remove(arg2);
41006 wxPyEndAllowThreads(__tstate);
41007 if (PyErr_Occurred()) SWIG_fail;
41008 }
41009 {
41010 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41011 }
41012 return resultobj;
41013 fail:
41014 return NULL;
41015 }
41016
41017
41018 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41019 PyObject *resultobj = 0;
41020 wxMenu *arg1 = (wxMenu *) 0 ;
41021 int arg2 ;
41022 bool result;
41023 void *argp1 = 0 ;
41024 int res1 = 0 ;
41025 int val2 ;
41026 int ecode2 = 0 ;
41027 PyObject * obj0 = 0 ;
41028 PyObject * obj1 = 0 ;
41029 char * kwnames[] = {
41030 (char *) "self",(char *) "id", NULL
41031 };
41032
41033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41035 if (!SWIG_IsOK(res1)) {
41036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41037 }
41038 arg1 = reinterpret_cast< wxMenu * >(argp1);
41039 ecode2 = SWIG_AsVal_int(obj1, &val2);
41040 if (!SWIG_IsOK(ecode2)) {
41041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41042 }
41043 arg2 = static_cast< int >(val2);
41044 {
41045 PyThreadState* __tstate = wxPyBeginAllowThreads();
41046 result = (bool)(arg1)->Delete(arg2);
41047 wxPyEndAllowThreads(__tstate);
41048 if (PyErr_Occurred()) SWIG_fail;
41049 }
41050 {
41051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41052 }
41053 return resultobj;
41054 fail:
41055 return NULL;
41056 }
41057
41058
41059 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41060 PyObject *resultobj = 0;
41061 wxMenu *arg1 = (wxMenu *) 0 ;
41062 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41063 bool result;
41064 void *argp1 = 0 ;
41065 int res1 = 0 ;
41066 void *argp2 = 0 ;
41067 int res2 = 0 ;
41068 PyObject * obj0 = 0 ;
41069 PyObject * obj1 = 0 ;
41070 char * kwnames[] = {
41071 (char *) "self",(char *) "item", NULL
41072 };
41073
41074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41076 if (!SWIG_IsOK(res1)) {
41077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41078 }
41079 arg1 = reinterpret_cast< wxMenu * >(argp1);
41080 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41081 if (!SWIG_IsOK(res2)) {
41082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41083 }
41084 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41085 {
41086 PyThreadState* __tstate = wxPyBeginAllowThreads();
41087 result = (bool)(arg1)->Delete(arg2);
41088 wxPyEndAllowThreads(__tstate);
41089 if (PyErr_Occurred()) SWIG_fail;
41090 }
41091 {
41092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41093 }
41094 return resultobj;
41095 fail:
41096 return NULL;
41097 }
41098
41099
41100 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41101 PyObject *resultobj = 0;
41102 wxMenu *arg1 = (wxMenu *) 0 ;
41103 void *argp1 = 0 ;
41104 int res1 = 0 ;
41105 PyObject *swig_obj[1] ;
41106
41107 if (!args) SWIG_fail;
41108 swig_obj[0] = args;
41109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41110 if (!SWIG_IsOK(res1)) {
41111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41112 }
41113 arg1 = reinterpret_cast< wxMenu * >(argp1);
41114 {
41115 PyThreadState* __tstate = wxPyBeginAllowThreads();
41116 wxMenu_Destroy(arg1);
41117 wxPyEndAllowThreads(__tstate);
41118 if (PyErr_Occurred()) SWIG_fail;
41119 }
41120 resultobj = SWIG_Py_Void();
41121 return resultobj;
41122 fail:
41123 return NULL;
41124 }
41125
41126
41127 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41128 PyObject *resultobj = 0;
41129 wxMenu *arg1 = (wxMenu *) 0 ;
41130 int arg2 ;
41131 bool result;
41132 void *argp1 = 0 ;
41133 int res1 = 0 ;
41134 int val2 ;
41135 int ecode2 = 0 ;
41136 PyObject * obj0 = 0 ;
41137 PyObject * obj1 = 0 ;
41138 char * kwnames[] = {
41139 (char *) "self",(char *) "id", NULL
41140 };
41141
41142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41144 if (!SWIG_IsOK(res1)) {
41145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41146 }
41147 arg1 = reinterpret_cast< wxMenu * >(argp1);
41148 ecode2 = SWIG_AsVal_int(obj1, &val2);
41149 if (!SWIG_IsOK(ecode2)) {
41150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41151 }
41152 arg2 = static_cast< int >(val2);
41153 {
41154 PyThreadState* __tstate = wxPyBeginAllowThreads();
41155 result = (bool)(arg1)->Destroy(arg2);
41156 wxPyEndAllowThreads(__tstate);
41157 if (PyErr_Occurred()) SWIG_fail;
41158 }
41159 {
41160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41161 }
41162 return resultobj;
41163 fail:
41164 return NULL;
41165 }
41166
41167
41168 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41169 PyObject *resultobj = 0;
41170 wxMenu *arg1 = (wxMenu *) 0 ;
41171 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41172 bool result;
41173 void *argp1 = 0 ;
41174 int res1 = 0 ;
41175 void *argp2 = 0 ;
41176 int res2 = 0 ;
41177 PyObject * obj0 = 0 ;
41178 PyObject * obj1 = 0 ;
41179 char * kwnames[] = {
41180 (char *) "self",(char *) "item", NULL
41181 };
41182
41183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41185 if (!SWIG_IsOK(res1)) {
41186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41187 }
41188 arg1 = reinterpret_cast< wxMenu * >(argp1);
41189 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41190 if (!SWIG_IsOK(res2)) {
41191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41192 }
41193 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 result = (bool)(arg1)->Destroy(arg2);
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 {
41201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41202 }
41203 return resultobj;
41204 fail:
41205 return NULL;
41206 }
41207
41208
41209 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41210 PyObject *resultobj = 0;
41211 wxMenu *arg1 = (wxMenu *) 0 ;
41212 size_t result;
41213 void *argp1 = 0 ;
41214 int res1 = 0 ;
41215 PyObject *swig_obj[1] ;
41216
41217 if (!args) SWIG_fail;
41218 swig_obj[0] = args;
41219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41220 if (!SWIG_IsOK(res1)) {
41221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41222 }
41223 arg1 = reinterpret_cast< wxMenu * >(argp1);
41224 {
41225 PyThreadState* __tstate = wxPyBeginAllowThreads();
41226 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41227 wxPyEndAllowThreads(__tstate);
41228 if (PyErr_Occurred()) SWIG_fail;
41229 }
41230 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41238 PyObject *resultobj = 0;
41239 wxMenu *arg1 = (wxMenu *) 0 ;
41240 PyObject *result = 0 ;
41241 void *argp1 = 0 ;
41242 int res1 = 0 ;
41243 PyObject *swig_obj[1] ;
41244
41245 if (!args) SWIG_fail;
41246 swig_obj[0] = args;
41247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41248 if (!SWIG_IsOK(res1)) {
41249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41250 }
41251 arg1 = reinterpret_cast< wxMenu * >(argp1);
41252 {
41253 PyThreadState* __tstate = wxPyBeginAllowThreads();
41254 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41255 wxPyEndAllowThreads(__tstate);
41256 if (PyErr_Occurred()) SWIG_fail;
41257 }
41258 resultobj = result;
41259 return resultobj;
41260 fail:
41261 return NULL;
41262 }
41263
41264
41265 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41266 PyObject *resultobj = 0;
41267 wxMenu *arg1 = (wxMenu *) 0 ;
41268 wxString *arg2 = 0 ;
41269 int result;
41270 void *argp1 = 0 ;
41271 int res1 = 0 ;
41272 bool temp2 = false ;
41273 PyObject * obj0 = 0 ;
41274 PyObject * obj1 = 0 ;
41275 char * kwnames[] = {
41276 (char *) "self",(char *) "item", NULL
41277 };
41278
41279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41281 if (!SWIG_IsOK(res1)) {
41282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41283 }
41284 arg1 = reinterpret_cast< wxMenu * >(argp1);
41285 {
41286 arg2 = wxString_in_helper(obj1);
41287 if (arg2 == NULL) SWIG_fail;
41288 temp2 = true;
41289 }
41290 {
41291 PyThreadState* __tstate = wxPyBeginAllowThreads();
41292 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41293 wxPyEndAllowThreads(__tstate);
41294 if (PyErr_Occurred()) SWIG_fail;
41295 }
41296 resultobj = SWIG_From_int(static_cast< int >(result));
41297 {
41298 if (temp2)
41299 delete arg2;
41300 }
41301 return resultobj;
41302 fail:
41303 {
41304 if (temp2)
41305 delete arg2;
41306 }
41307 return NULL;
41308 }
41309
41310
41311 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41312 PyObject *resultobj = 0;
41313 wxMenu *arg1 = (wxMenu *) 0 ;
41314 int arg2 ;
41315 wxMenuItem *result = 0 ;
41316 void *argp1 = 0 ;
41317 int res1 = 0 ;
41318 int val2 ;
41319 int ecode2 = 0 ;
41320 PyObject * obj0 = 0 ;
41321 PyObject * obj1 = 0 ;
41322 char * kwnames[] = {
41323 (char *) "self",(char *) "id", NULL
41324 };
41325
41326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41328 if (!SWIG_IsOK(res1)) {
41329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41330 }
41331 arg1 = reinterpret_cast< wxMenu * >(argp1);
41332 ecode2 = SWIG_AsVal_int(obj1, &val2);
41333 if (!SWIG_IsOK(ecode2)) {
41334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41335 }
41336 arg2 = static_cast< int >(val2);
41337 {
41338 PyThreadState* __tstate = wxPyBeginAllowThreads();
41339 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41340 wxPyEndAllowThreads(__tstate);
41341 if (PyErr_Occurred()) SWIG_fail;
41342 }
41343 {
41344 resultobj = wxPyMake_wxObject(result, (bool)0);
41345 }
41346 return resultobj;
41347 fail:
41348 return NULL;
41349 }
41350
41351
41352 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41353 PyObject *resultobj = 0;
41354 wxMenu *arg1 = (wxMenu *) 0 ;
41355 size_t arg2 ;
41356 wxMenuItem *result = 0 ;
41357 void *argp1 = 0 ;
41358 int res1 = 0 ;
41359 size_t val2 ;
41360 int ecode2 = 0 ;
41361 PyObject * obj0 = 0 ;
41362 PyObject * obj1 = 0 ;
41363 char * kwnames[] = {
41364 (char *) "self",(char *) "position", NULL
41365 };
41366
41367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41369 if (!SWIG_IsOK(res1)) {
41370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41371 }
41372 arg1 = reinterpret_cast< wxMenu * >(argp1);
41373 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41374 if (!SWIG_IsOK(ecode2)) {
41375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41376 }
41377 arg2 = static_cast< size_t >(val2);
41378 {
41379 PyThreadState* __tstate = wxPyBeginAllowThreads();
41380 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 {
41385 resultobj = wxPyMake_wxObject(result, (bool)0);
41386 }
41387 return resultobj;
41388 fail:
41389 return NULL;
41390 }
41391
41392
41393 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj = 0;
41395 wxMenu *arg1 = (wxMenu *) 0 ;
41396 int arg2 ;
41397 bool arg3 ;
41398 void *argp1 = 0 ;
41399 int res1 = 0 ;
41400 int val2 ;
41401 int ecode2 = 0 ;
41402 bool val3 ;
41403 int ecode3 = 0 ;
41404 PyObject * obj0 = 0 ;
41405 PyObject * obj1 = 0 ;
41406 PyObject * obj2 = 0 ;
41407 char * kwnames[] = {
41408 (char *) "self",(char *) "id",(char *) "enable", NULL
41409 };
41410
41411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41413 if (!SWIG_IsOK(res1)) {
41414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41415 }
41416 arg1 = reinterpret_cast< wxMenu * >(argp1);
41417 ecode2 = SWIG_AsVal_int(obj1, &val2);
41418 if (!SWIG_IsOK(ecode2)) {
41419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41420 }
41421 arg2 = static_cast< int >(val2);
41422 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41423 if (!SWIG_IsOK(ecode3)) {
41424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41425 }
41426 arg3 = static_cast< bool >(val3);
41427 {
41428 PyThreadState* __tstate = wxPyBeginAllowThreads();
41429 (arg1)->Enable(arg2,arg3);
41430 wxPyEndAllowThreads(__tstate);
41431 if (PyErr_Occurred()) SWIG_fail;
41432 }
41433 resultobj = SWIG_Py_Void();
41434 return resultobj;
41435 fail:
41436 return NULL;
41437 }
41438
41439
41440 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41441 PyObject *resultobj = 0;
41442 wxMenu *arg1 = (wxMenu *) 0 ;
41443 int arg2 ;
41444 bool result;
41445 void *argp1 = 0 ;
41446 int res1 = 0 ;
41447 int val2 ;
41448 int ecode2 = 0 ;
41449 PyObject * obj0 = 0 ;
41450 PyObject * obj1 = 0 ;
41451 char * kwnames[] = {
41452 (char *) "self",(char *) "id", NULL
41453 };
41454
41455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41457 if (!SWIG_IsOK(res1)) {
41458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41459 }
41460 arg1 = reinterpret_cast< wxMenu * >(argp1);
41461 ecode2 = SWIG_AsVal_int(obj1, &val2);
41462 if (!SWIG_IsOK(ecode2)) {
41463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41464 }
41465 arg2 = static_cast< int >(val2);
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41469 wxPyEndAllowThreads(__tstate);
41470 if (PyErr_Occurred()) SWIG_fail;
41471 }
41472 {
41473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41474 }
41475 return resultobj;
41476 fail:
41477 return NULL;
41478 }
41479
41480
41481 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41482 PyObject *resultobj = 0;
41483 wxMenu *arg1 = (wxMenu *) 0 ;
41484 int arg2 ;
41485 bool arg3 ;
41486 void *argp1 = 0 ;
41487 int res1 = 0 ;
41488 int val2 ;
41489 int ecode2 = 0 ;
41490 bool val3 ;
41491 int ecode3 = 0 ;
41492 PyObject * obj0 = 0 ;
41493 PyObject * obj1 = 0 ;
41494 PyObject * obj2 = 0 ;
41495 char * kwnames[] = {
41496 (char *) "self",(char *) "id",(char *) "check", NULL
41497 };
41498
41499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41501 if (!SWIG_IsOK(res1)) {
41502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41503 }
41504 arg1 = reinterpret_cast< wxMenu * >(argp1);
41505 ecode2 = SWIG_AsVal_int(obj1, &val2);
41506 if (!SWIG_IsOK(ecode2)) {
41507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41508 }
41509 arg2 = static_cast< int >(val2);
41510 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41511 if (!SWIG_IsOK(ecode3)) {
41512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41513 }
41514 arg3 = static_cast< bool >(val3);
41515 {
41516 PyThreadState* __tstate = wxPyBeginAllowThreads();
41517 (arg1)->Check(arg2,arg3);
41518 wxPyEndAllowThreads(__tstate);
41519 if (PyErr_Occurred()) SWIG_fail;
41520 }
41521 resultobj = SWIG_Py_Void();
41522 return resultobj;
41523 fail:
41524 return NULL;
41525 }
41526
41527
41528 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41529 PyObject *resultobj = 0;
41530 wxMenu *arg1 = (wxMenu *) 0 ;
41531 int arg2 ;
41532 bool result;
41533 void *argp1 = 0 ;
41534 int res1 = 0 ;
41535 int val2 ;
41536 int ecode2 = 0 ;
41537 PyObject * obj0 = 0 ;
41538 PyObject * obj1 = 0 ;
41539 char * kwnames[] = {
41540 (char *) "self",(char *) "id", NULL
41541 };
41542
41543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41545 if (!SWIG_IsOK(res1)) {
41546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41547 }
41548 arg1 = reinterpret_cast< wxMenu * >(argp1);
41549 ecode2 = SWIG_AsVal_int(obj1, &val2);
41550 if (!SWIG_IsOK(ecode2)) {
41551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41552 }
41553 arg2 = static_cast< int >(val2);
41554 {
41555 PyThreadState* __tstate = wxPyBeginAllowThreads();
41556 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41557 wxPyEndAllowThreads(__tstate);
41558 if (PyErr_Occurred()) SWIG_fail;
41559 }
41560 {
41561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41562 }
41563 return resultobj;
41564 fail:
41565 return NULL;
41566 }
41567
41568
41569 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41570 PyObject *resultobj = 0;
41571 wxMenu *arg1 = (wxMenu *) 0 ;
41572 int arg2 ;
41573 wxString *arg3 = 0 ;
41574 void *argp1 = 0 ;
41575 int res1 = 0 ;
41576 int val2 ;
41577 int ecode2 = 0 ;
41578 bool temp3 = false ;
41579 PyObject * obj0 = 0 ;
41580 PyObject * obj1 = 0 ;
41581 PyObject * obj2 = 0 ;
41582 char * kwnames[] = {
41583 (char *) "self",(char *) "id",(char *) "label", NULL
41584 };
41585
41586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41588 if (!SWIG_IsOK(res1)) {
41589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41590 }
41591 arg1 = reinterpret_cast< wxMenu * >(argp1);
41592 ecode2 = SWIG_AsVal_int(obj1, &val2);
41593 if (!SWIG_IsOK(ecode2)) {
41594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41595 }
41596 arg2 = static_cast< int >(val2);
41597 {
41598 arg3 = wxString_in_helper(obj2);
41599 if (arg3 == NULL) SWIG_fail;
41600 temp3 = true;
41601 }
41602 {
41603 PyThreadState* __tstate = wxPyBeginAllowThreads();
41604 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41605 wxPyEndAllowThreads(__tstate);
41606 if (PyErr_Occurred()) SWIG_fail;
41607 }
41608 resultobj = SWIG_Py_Void();
41609 {
41610 if (temp3)
41611 delete arg3;
41612 }
41613 return resultobj;
41614 fail:
41615 {
41616 if (temp3)
41617 delete arg3;
41618 }
41619 return NULL;
41620 }
41621
41622
41623 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41624 PyObject *resultobj = 0;
41625 wxMenu *arg1 = (wxMenu *) 0 ;
41626 int arg2 ;
41627 wxString result;
41628 void *argp1 = 0 ;
41629 int res1 = 0 ;
41630 int val2 ;
41631 int ecode2 = 0 ;
41632 PyObject * obj0 = 0 ;
41633 PyObject * obj1 = 0 ;
41634 char * kwnames[] = {
41635 (char *) "self",(char *) "id", NULL
41636 };
41637
41638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41640 if (!SWIG_IsOK(res1)) {
41641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41642 }
41643 arg1 = reinterpret_cast< wxMenu * >(argp1);
41644 ecode2 = SWIG_AsVal_int(obj1, &val2);
41645 if (!SWIG_IsOK(ecode2)) {
41646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41647 }
41648 arg2 = static_cast< int >(val2);
41649 {
41650 PyThreadState* __tstate = wxPyBeginAllowThreads();
41651 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41652 wxPyEndAllowThreads(__tstate);
41653 if (PyErr_Occurred()) SWIG_fail;
41654 }
41655 {
41656 #if wxUSE_UNICODE
41657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41658 #else
41659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41660 #endif
41661 }
41662 return resultobj;
41663 fail:
41664 return NULL;
41665 }
41666
41667
41668 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41669 PyObject *resultobj = 0;
41670 wxMenu *arg1 = (wxMenu *) 0 ;
41671 int arg2 ;
41672 wxString *arg3 = 0 ;
41673 void *argp1 = 0 ;
41674 int res1 = 0 ;
41675 int val2 ;
41676 int ecode2 = 0 ;
41677 bool temp3 = false ;
41678 PyObject * obj0 = 0 ;
41679 PyObject * obj1 = 0 ;
41680 PyObject * obj2 = 0 ;
41681 char * kwnames[] = {
41682 (char *) "self",(char *) "id",(char *) "helpString", NULL
41683 };
41684
41685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41687 if (!SWIG_IsOK(res1)) {
41688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41689 }
41690 arg1 = reinterpret_cast< wxMenu * >(argp1);
41691 ecode2 = SWIG_AsVal_int(obj1, &val2);
41692 if (!SWIG_IsOK(ecode2)) {
41693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41694 }
41695 arg2 = static_cast< int >(val2);
41696 {
41697 arg3 = wxString_in_helper(obj2);
41698 if (arg3 == NULL) SWIG_fail;
41699 temp3 = true;
41700 }
41701 {
41702 PyThreadState* __tstate = wxPyBeginAllowThreads();
41703 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41704 wxPyEndAllowThreads(__tstate);
41705 if (PyErr_Occurred()) SWIG_fail;
41706 }
41707 resultobj = SWIG_Py_Void();
41708 {
41709 if (temp3)
41710 delete arg3;
41711 }
41712 return resultobj;
41713 fail:
41714 {
41715 if (temp3)
41716 delete arg3;
41717 }
41718 return NULL;
41719 }
41720
41721
41722 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41723 PyObject *resultobj = 0;
41724 wxMenu *arg1 = (wxMenu *) 0 ;
41725 int arg2 ;
41726 wxString result;
41727 void *argp1 = 0 ;
41728 int res1 = 0 ;
41729 int val2 ;
41730 int ecode2 = 0 ;
41731 PyObject * obj0 = 0 ;
41732 PyObject * obj1 = 0 ;
41733 char * kwnames[] = {
41734 (char *) "self",(char *) "id", NULL
41735 };
41736
41737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41739 if (!SWIG_IsOK(res1)) {
41740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41741 }
41742 arg1 = reinterpret_cast< wxMenu * >(argp1);
41743 ecode2 = SWIG_AsVal_int(obj1, &val2);
41744 if (!SWIG_IsOK(ecode2)) {
41745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41746 }
41747 arg2 = static_cast< int >(val2);
41748 {
41749 PyThreadState* __tstate = wxPyBeginAllowThreads();
41750 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 {
41755 #if wxUSE_UNICODE
41756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41757 #else
41758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41759 #endif
41760 }
41761 return resultobj;
41762 fail:
41763 return NULL;
41764 }
41765
41766
41767 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41768 PyObject *resultobj = 0;
41769 wxMenu *arg1 = (wxMenu *) 0 ;
41770 wxString *arg2 = 0 ;
41771 void *argp1 = 0 ;
41772 int res1 = 0 ;
41773 bool temp2 = false ;
41774 PyObject * obj0 = 0 ;
41775 PyObject * obj1 = 0 ;
41776 char * kwnames[] = {
41777 (char *) "self",(char *) "title", NULL
41778 };
41779
41780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41782 if (!SWIG_IsOK(res1)) {
41783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41784 }
41785 arg1 = reinterpret_cast< wxMenu * >(argp1);
41786 {
41787 arg2 = wxString_in_helper(obj1);
41788 if (arg2 == NULL) SWIG_fail;
41789 temp2 = true;
41790 }
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 (arg1)->SetTitle((wxString const &)*arg2);
41794 wxPyEndAllowThreads(__tstate);
41795 if (PyErr_Occurred()) SWIG_fail;
41796 }
41797 resultobj = SWIG_Py_Void();
41798 {
41799 if (temp2)
41800 delete arg2;
41801 }
41802 return resultobj;
41803 fail:
41804 {
41805 if (temp2)
41806 delete arg2;
41807 }
41808 return NULL;
41809 }
41810
41811
41812 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41813 PyObject *resultobj = 0;
41814 wxMenu *arg1 = (wxMenu *) 0 ;
41815 wxString result;
41816 void *argp1 = 0 ;
41817 int res1 = 0 ;
41818 PyObject *swig_obj[1] ;
41819
41820 if (!args) SWIG_fail;
41821 swig_obj[0] = args;
41822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41823 if (!SWIG_IsOK(res1)) {
41824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41825 }
41826 arg1 = reinterpret_cast< wxMenu * >(argp1);
41827 {
41828 PyThreadState* __tstate = wxPyBeginAllowThreads();
41829 result = ((wxMenu const *)arg1)->GetTitle();
41830 wxPyEndAllowThreads(__tstate);
41831 if (PyErr_Occurred()) SWIG_fail;
41832 }
41833 {
41834 #if wxUSE_UNICODE
41835 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41836 #else
41837 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41838 #endif
41839 }
41840 return resultobj;
41841 fail:
41842 return NULL;
41843 }
41844
41845
41846 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41847 PyObject *resultobj = 0;
41848 wxMenu *arg1 = (wxMenu *) 0 ;
41849 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41850 void *argp1 = 0 ;
41851 int res1 = 0 ;
41852 void *argp2 = 0 ;
41853 int res2 = 0 ;
41854 PyObject * obj0 = 0 ;
41855 PyObject * obj1 = 0 ;
41856 char * kwnames[] = {
41857 (char *) "self",(char *) "handler", NULL
41858 };
41859
41860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41862 if (!SWIG_IsOK(res1)) {
41863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41864 }
41865 arg1 = reinterpret_cast< wxMenu * >(argp1);
41866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41867 if (!SWIG_IsOK(res2)) {
41868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41869 }
41870 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41871 {
41872 PyThreadState* __tstate = wxPyBeginAllowThreads();
41873 (arg1)->SetEventHandler(arg2);
41874 wxPyEndAllowThreads(__tstate);
41875 if (PyErr_Occurred()) SWIG_fail;
41876 }
41877 resultobj = SWIG_Py_Void();
41878 return resultobj;
41879 fail:
41880 return NULL;
41881 }
41882
41883
41884 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41885 PyObject *resultobj = 0;
41886 wxMenu *arg1 = (wxMenu *) 0 ;
41887 wxEvtHandler *result = 0 ;
41888 void *argp1 = 0 ;
41889 int res1 = 0 ;
41890 PyObject *swig_obj[1] ;
41891
41892 if (!args) SWIG_fail;
41893 swig_obj[0] = args;
41894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41895 if (!SWIG_IsOK(res1)) {
41896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41897 }
41898 arg1 = reinterpret_cast< wxMenu * >(argp1);
41899 {
41900 PyThreadState* __tstate = wxPyBeginAllowThreads();
41901 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41902 wxPyEndAllowThreads(__tstate);
41903 if (PyErr_Occurred()) SWIG_fail;
41904 }
41905 {
41906 resultobj = wxPyMake_wxObject(result, 0);
41907 }
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41915 PyObject *resultobj = 0;
41916 wxMenu *arg1 = (wxMenu *) 0 ;
41917 wxWindow *arg2 = (wxWindow *) 0 ;
41918 void *argp1 = 0 ;
41919 int res1 = 0 ;
41920 void *argp2 = 0 ;
41921 int res2 = 0 ;
41922 PyObject * obj0 = 0 ;
41923 PyObject * obj1 = 0 ;
41924 char * kwnames[] = {
41925 (char *) "self",(char *) "win", NULL
41926 };
41927
41928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41930 if (!SWIG_IsOK(res1)) {
41931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41932 }
41933 arg1 = reinterpret_cast< wxMenu * >(argp1);
41934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41935 if (!SWIG_IsOK(res2)) {
41936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41937 }
41938 arg2 = reinterpret_cast< wxWindow * >(argp2);
41939 {
41940 PyThreadState* __tstate = wxPyBeginAllowThreads();
41941 (arg1)->SetInvokingWindow(arg2);
41942 wxPyEndAllowThreads(__tstate);
41943 if (PyErr_Occurred()) SWIG_fail;
41944 }
41945 resultobj = SWIG_Py_Void();
41946 return resultobj;
41947 fail:
41948 return NULL;
41949 }
41950
41951
41952 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41953 PyObject *resultobj = 0;
41954 wxMenu *arg1 = (wxMenu *) 0 ;
41955 wxWindow *result = 0 ;
41956 void *argp1 = 0 ;
41957 int res1 = 0 ;
41958 PyObject *swig_obj[1] ;
41959
41960 if (!args) SWIG_fail;
41961 swig_obj[0] = args;
41962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41963 if (!SWIG_IsOK(res1)) {
41964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41965 }
41966 arg1 = reinterpret_cast< wxMenu * >(argp1);
41967 {
41968 PyThreadState* __tstate = wxPyBeginAllowThreads();
41969 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41970 wxPyEndAllowThreads(__tstate);
41971 if (PyErr_Occurred()) SWIG_fail;
41972 }
41973 {
41974 resultobj = wxPyMake_wxObject(result, 0);
41975 }
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41983 PyObject *resultobj = 0;
41984 wxMenu *arg1 = (wxMenu *) 0 ;
41985 long result;
41986 void *argp1 = 0 ;
41987 int res1 = 0 ;
41988 PyObject *swig_obj[1] ;
41989
41990 if (!args) SWIG_fail;
41991 swig_obj[0] = args;
41992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41993 if (!SWIG_IsOK(res1)) {
41994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41995 }
41996 arg1 = reinterpret_cast< wxMenu * >(argp1);
41997 {
41998 PyThreadState* __tstate = wxPyBeginAllowThreads();
41999 result = (long)((wxMenu const *)arg1)->GetStyle();
42000 wxPyEndAllowThreads(__tstate);
42001 if (PyErr_Occurred()) SWIG_fail;
42002 }
42003 resultobj = SWIG_From_long(static_cast< long >(result));
42004 return resultobj;
42005 fail:
42006 return NULL;
42007 }
42008
42009
42010 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42011 PyObject *resultobj = 0;
42012 wxMenu *arg1 = (wxMenu *) 0 ;
42013 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42014 void *argp1 = 0 ;
42015 int res1 = 0 ;
42016 void *argp2 = 0 ;
42017 int res2 = 0 ;
42018 PyObject * obj0 = 0 ;
42019 PyObject * obj1 = 0 ;
42020 char * kwnames[] = {
42021 (char *) "self",(char *) "source", NULL
42022 };
42023
42024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42026 if (!SWIG_IsOK(res1)) {
42027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42028 }
42029 arg1 = reinterpret_cast< wxMenu * >(argp1);
42030 if (obj1) {
42031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42032 if (!SWIG_IsOK(res2)) {
42033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42034 }
42035 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42036 }
42037 {
42038 PyThreadState* __tstate = wxPyBeginAllowThreads();
42039 (arg1)->UpdateUI(arg2);
42040 wxPyEndAllowThreads(__tstate);
42041 if (PyErr_Occurred()) SWIG_fail;
42042 }
42043 resultobj = SWIG_Py_Void();
42044 return resultobj;
42045 fail:
42046 return NULL;
42047 }
42048
42049
42050 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42051 PyObject *resultobj = 0;
42052 wxMenu *arg1 = (wxMenu *) 0 ;
42053 wxMenuBar *result = 0 ;
42054 void *argp1 = 0 ;
42055 int res1 = 0 ;
42056 PyObject *swig_obj[1] ;
42057
42058 if (!args) SWIG_fail;
42059 swig_obj[0] = args;
42060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42061 if (!SWIG_IsOK(res1)) {
42062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42063 }
42064 arg1 = reinterpret_cast< wxMenu * >(argp1);
42065 {
42066 PyThreadState* __tstate = wxPyBeginAllowThreads();
42067 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42068 wxPyEndAllowThreads(__tstate);
42069 if (PyErr_Occurred()) SWIG_fail;
42070 }
42071 {
42072 resultobj = wxPyMake_wxObject(result, (bool)0);
42073 }
42074 return resultobj;
42075 fail:
42076 return NULL;
42077 }
42078
42079
42080 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42081 PyObject *resultobj = 0;
42082 wxMenu *arg1 = (wxMenu *) 0 ;
42083 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42084 void *argp1 = 0 ;
42085 int res1 = 0 ;
42086 void *argp2 = 0 ;
42087 int res2 = 0 ;
42088 PyObject * obj0 = 0 ;
42089 PyObject * obj1 = 0 ;
42090 char * kwnames[] = {
42091 (char *) "self",(char *) "menubar", NULL
42092 };
42093
42094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42096 if (!SWIG_IsOK(res1)) {
42097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42098 }
42099 arg1 = reinterpret_cast< wxMenu * >(argp1);
42100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42101 if (!SWIG_IsOK(res2)) {
42102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42103 }
42104 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42105 {
42106 PyThreadState* __tstate = wxPyBeginAllowThreads();
42107 (arg1)->Attach(arg2);
42108 wxPyEndAllowThreads(__tstate);
42109 if (PyErr_Occurred()) SWIG_fail;
42110 }
42111 resultobj = SWIG_Py_Void();
42112 return resultobj;
42113 fail:
42114 return NULL;
42115 }
42116
42117
42118 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42119 PyObject *resultobj = 0;
42120 wxMenu *arg1 = (wxMenu *) 0 ;
42121 void *argp1 = 0 ;
42122 int res1 = 0 ;
42123 PyObject *swig_obj[1] ;
42124
42125 if (!args) SWIG_fail;
42126 swig_obj[0] = args;
42127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42128 if (!SWIG_IsOK(res1)) {
42129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42130 }
42131 arg1 = reinterpret_cast< wxMenu * >(argp1);
42132 {
42133 PyThreadState* __tstate = wxPyBeginAllowThreads();
42134 (arg1)->Detach();
42135 wxPyEndAllowThreads(__tstate);
42136 if (PyErr_Occurred()) SWIG_fail;
42137 }
42138 resultobj = SWIG_Py_Void();
42139 return resultobj;
42140 fail:
42141 return NULL;
42142 }
42143
42144
42145 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42146 PyObject *resultobj = 0;
42147 wxMenu *arg1 = (wxMenu *) 0 ;
42148 bool result;
42149 void *argp1 = 0 ;
42150 int res1 = 0 ;
42151 PyObject *swig_obj[1] ;
42152
42153 if (!args) SWIG_fail;
42154 swig_obj[0] = args;
42155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42156 if (!SWIG_IsOK(res1)) {
42157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42158 }
42159 arg1 = reinterpret_cast< wxMenu * >(argp1);
42160 {
42161 PyThreadState* __tstate = wxPyBeginAllowThreads();
42162 result = (bool)((wxMenu const *)arg1)->IsAttached();
42163 wxPyEndAllowThreads(__tstate);
42164 if (PyErr_Occurred()) SWIG_fail;
42165 }
42166 {
42167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42168 }
42169 return resultobj;
42170 fail:
42171 return NULL;
42172 }
42173
42174
42175 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42176 PyObject *resultobj = 0;
42177 wxMenu *arg1 = (wxMenu *) 0 ;
42178 wxMenu *arg2 = (wxMenu *) 0 ;
42179 void *argp1 = 0 ;
42180 int res1 = 0 ;
42181 void *argp2 = 0 ;
42182 int res2 = 0 ;
42183 PyObject * obj0 = 0 ;
42184 PyObject * obj1 = 0 ;
42185 char * kwnames[] = {
42186 (char *) "self",(char *) "parent", NULL
42187 };
42188
42189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42191 if (!SWIG_IsOK(res1)) {
42192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42193 }
42194 arg1 = reinterpret_cast< wxMenu * >(argp1);
42195 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42196 if (!SWIG_IsOK(res2)) {
42197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42198 }
42199 arg2 = reinterpret_cast< wxMenu * >(argp2);
42200 {
42201 PyThreadState* __tstate = wxPyBeginAllowThreads();
42202 (arg1)->SetParent(arg2);
42203 wxPyEndAllowThreads(__tstate);
42204 if (PyErr_Occurred()) SWIG_fail;
42205 }
42206 resultobj = SWIG_Py_Void();
42207 return resultobj;
42208 fail:
42209 return NULL;
42210 }
42211
42212
42213 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42214 PyObject *resultobj = 0;
42215 wxMenu *arg1 = (wxMenu *) 0 ;
42216 wxMenu *result = 0 ;
42217 void *argp1 = 0 ;
42218 int res1 = 0 ;
42219 PyObject *swig_obj[1] ;
42220
42221 if (!args) SWIG_fail;
42222 swig_obj[0] = args;
42223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42224 if (!SWIG_IsOK(res1)) {
42225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42226 }
42227 arg1 = reinterpret_cast< wxMenu * >(argp1);
42228 {
42229 PyThreadState* __tstate = wxPyBeginAllowThreads();
42230 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42231 wxPyEndAllowThreads(__tstate);
42232 if (PyErr_Occurred()) SWIG_fail;
42233 }
42234 {
42235 resultobj = wxPyMake_wxObject(result, 0);
42236 }
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42244 PyObject *obj;
42245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42246 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42247 return SWIG_Py_Void();
42248 }
42249
42250 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42251 return SWIG_Python_InitShadowInstance(args);
42252 }
42253
42254 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42255 PyObject *resultobj = 0;
42256 long arg1 = (long) 0 ;
42257 wxMenuBar *result = 0 ;
42258 long val1 ;
42259 int ecode1 = 0 ;
42260 PyObject * obj0 = 0 ;
42261 char * kwnames[] = {
42262 (char *) "style", NULL
42263 };
42264
42265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42266 if (obj0) {
42267 ecode1 = SWIG_AsVal_long(obj0, &val1);
42268 if (!SWIG_IsOK(ecode1)) {
42269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42270 }
42271 arg1 = static_cast< long >(val1);
42272 }
42273 {
42274 if (!wxPyCheckForApp()) SWIG_fail;
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 result = (wxMenuBar *)new wxMenuBar(arg1);
42277 wxPyEndAllowThreads(__tstate);
42278 if (PyErr_Occurred()) SWIG_fail;
42279 }
42280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42281 return resultobj;
42282 fail:
42283 return NULL;
42284 }
42285
42286
42287 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42288 PyObject *resultobj = 0;
42289 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42290 wxMenu *arg2 = (wxMenu *) 0 ;
42291 wxString *arg3 = 0 ;
42292 bool result;
42293 void *argp1 = 0 ;
42294 int res1 = 0 ;
42295 void *argp2 = 0 ;
42296 int res2 = 0 ;
42297 bool temp3 = false ;
42298 PyObject * obj0 = 0 ;
42299 PyObject * obj1 = 0 ;
42300 PyObject * obj2 = 0 ;
42301 char * kwnames[] = {
42302 (char *) "self",(char *) "menu",(char *) "title", NULL
42303 };
42304
42305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42307 if (!SWIG_IsOK(res1)) {
42308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42309 }
42310 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42312 if (!SWIG_IsOK(res2)) {
42313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42314 }
42315 arg2 = reinterpret_cast< wxMenu * >(argp2);
42316 {
42317 arg3 = wxString_in_helper(obj2);
42318 if (arg3 == NULL) SWIG_fail;
42319 temp3 = true;
42320 }
42321 {
42322 PyThreadState* __tstate = wxPyBeginAllowThreads();
42323 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 {
42328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42329 }
42330 {
42331 if (temp3)
42332 delete arg3;
42333 }
42334 return resultobj;
42335 fail:
42336 {
42337 if (temp3)
42338 delete arg3;
42339 }
42340 return NULL;
42341 }
42342
42343
42344 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42345 PyObject *resultobj = 0;
42346 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42347 size_t arg2 ;
42348 wxMenu *arg3 = (wxMenu *) 0 ;
42349 wxString *arg4 = 0 ;
42350 bool result;
42351 void *argp1 = 0 ;
42352 int res1 = 0 ;
42353 size_t val2 ;
42354 int ecode2 = 0 ;
42355 void *argp3 = 0 ;
42356 int res3 = 0 ;
42357 bool temp4 = false ;
42358 PyObject * obj0 = 0 ;
42359 PyObject * obj1 = 0 ;
42360 PyObject * obj2 = 0 ;
42361 PyObject * obj3 = 0 ;
42362 char * kwnames[] = {
42363 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42364 };
42365
42366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42368 if (!SWIG_IsOK(res1)) {
42369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42370 }
42371 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42372 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42373 if (!SWIG_IsOK(ecode2)) {
42374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42375 }
42376 arg2 = static_cast< size_t >(val2);
42377 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42378 if (!SWIG_IsOK(res3)) {
42379 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42380 }
42381 arg3 = reinterpret_cast< wxMenu * >(argp3);
42382 {
42383 arg4 = wxString_in_helper(obj3);
42384 if (arg4 == NULL) SWIG_fail;
42385 temp4 = true;
42386 }
42387 {
42388 PyThreadState* __tstate = wxPyBeginAllowThreads();
42389 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42390 wxPyEndAllowThreads(__tstate);
42391 if (PyErr_Occurred()) SWIG_fail;
42392 }
42393 {
42394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42395 }
42396 {
42397 if (temp4)
42398 delete arg4;
42399 }
42400 return resultobj;
42401 fail:
42402 {
42403 if (temp4)
42404 delete arg4;
42405 }
42406 return NULL;
42407 }
42408
42409
42410 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42411 PyObject *resultobj = 0;
42412 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42413 size_t result;
42414 void *argp1 = 0 ;
42415 int res1 = 0 ;
42416 PyObject *swig_obj[1] ;
42417
42418 if (!args) SWIG_fail;
42419 swig_obj[0] = args;
42420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42421 if (!SWIG_IsOK(res1)) {
42422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42423 }
42424 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42428 wxPyEndAllowThreads(__tstate);
42429 if (PyErr_Occurred()) SWIG_fail;
42430 }
42431 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42432 return resultobj;
42433 fail:
42434 return NULL;
42435 }
42436
42437
42438 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42439 PyObject *resultobj = 0;
42440 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42441 size_t arg2 ;
42442 wxMenu *result = 0 ;
42443 void *argp1 = 0 ;
42444 int res1 = 0 ;
42445 size_t val2 ;
42446 int ecode2 = 0 ;
42447 PyObject * obj0 = 0 ;
42448 PyObject * obj1 = 0 ;
42449 char * kwnames[] = {
42450 (char *) "self",(char *) "pos", NULL
42451 };
42452
42453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42455 if (!SWIG_IsOK(res1)) {
42456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42457 }
42458 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42459 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42460 if (!SWIG_IsOK(ecode2)) {
42461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42462 }
42463 arg2 = static_cast< size_t >(val2);
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42467 wxPyEndAllowThreads(__tstate);
42468 if (PyErr_Occurred()) SWIG_fail;
42469 }
42470 {
42471 resultobj = wxPyMake_wxObject(result, 0);
42472 }
42473 return resultobj;
42474 fail:
42475 return NULL;
42476 }
42477
42478
42479 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42480 PyObject *resultobj = 0;
42481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42482 size_t arg2 ;
42483 wxMenu *arg3 = (wxMenu *) 0 ;
42484 wxString *arg4 = 0 ;
42485 wxMenu *result = 0 ;
42486 void *argp1 = 0 ;
42487 int res1 = 0 ;
42488 size_t val2 ;
42489 int ecode2 = 0 ;
42490 void *argp3 = 0 ;
42491 int res3 = 0 ;
42492 bool temp4 = false ;
42493 PyObject * obj0 = 0 ;
42494 PyObject * obj1 = 0 ;
42495 PyObject * obj2 = 0 ;
42496 PyObject * obj3 = 0 ;
42497 char * kwnames[] = {
42498 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42499 };
42500
42501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42503 if (!SWIG_IsOK(res1)) {
42504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42505 }
42506 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42507 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42508 if (!SWIG_IsOK(ecode2)) {
42509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42510 }
42511 arg2 = static_cast< size_t >(val2);
42512 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42513 if (!SWIG_IsOK(res3)) {
42514 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42515 }
42516 arg3 = reinterpret_cast< wxMenu * >(argp3);
42517 {
42518 arg4 = wxString_in_helper(obj3);
42519 if (arg4 == NULL) SWIG_fail;
42520 temp4 = true;
42521 }
42522 {
42523 PyThreadState* __tstate = wxPyBeginAllowThreads();
42524 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42525 wxPyEndAllowThreads(__tstate);
42526 if (PyErr_Occurred()) SWIG_fail;
42527 }
42528 {
42529 resultobj = wxPyMake_wxObject(result, 0);
42530 }
42531 {
42532 if (temp4)
42533 delete arg4;
42534 }
42535 return resultobj;
42536 fail:
42537 {
42538 if (temp4)
42539 delete arg4;
42540 }
42541 return NULL;
42542 }
42543
42544
42545 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42546 PyObject *resultobj = 0;
42547 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42548 size_t arg2 ;
42549 wxMenu *result = 0 ;
42550 void *argp1 = 0 ;
42551 int res1 = 0 ;
42552 size_t val2 ;
42553 int ecode2 = 0 ;
42554 PyObject * obj0 = 0 ;
42555 PyObject * obj1 = 0 ;
42556 char * kwnames[] = {
42557 (char *) "self",(char *) "pos", NULL
42558 };
42559
42560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42562 if (!SWIG_IsOK(res1)) {
42563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42564 }
42565 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42566 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42567 if (!SWIG_IsOK(ecode2)) {
42568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42569 }
42570 arg2 = static_cast< size_t >(val2);
42571 {
42572 PyThreadState* __tstate = wxPyBeginAllowThreads();
42573 result = (wxMenu *)(arg1)->Remove(arg2);
42574 wxPyEndAllowThreads(__tstate);
42575 if (PyErr_Occurred()) SWIG_fail;
42576 }
42577 {
42578 resultobj = wxPyMake_wxObject(result, 0);
42579 }
42580 return resultobj;
42581 fail:
42582 return NULL;
42583 }
42584
42585
42586 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42587 PyObject *resultobj = 0;
42588 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42589 size_t arg2 ;
42590 bool arg3 ;
42591 void *argp1 = 0 ;
42592 int res1 = 0 ;
42593 size_t val2 ;
42594 int ecode2 = 0 ;
42595 bool val3 ;
42596 int ecode3 = 0 ;
42597 PyObject * obj0 = 0 ;
42598 PyObject * obj1 = 0 ;
42599 PyObject * obj2 = 0 ;
42600 char * kwnames[] = {
42601 (char *) "self",(char *) "pos",(char *) "enable", NULL
42602 };
42603
42604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42606 if (!SWIG_IsOK(res1)) {
42607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42608 }
42609 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42610 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42611 if (!SWIG_IsOK(ecode2)) {
42612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42613 }
42614 arg2 = static_cast< size_t >(val2);
42615 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42616 if (!SWIG_IsOK(ecode3)) {
42617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42618 }
42619 arg3 = static_cast< bool >(val3);
42620 {
42621 PyThreadState* __tstate = wxPyBeginAllowThreads();
42622 (arg1)->EnableTop(arg2,arg3);
42623 wxPyEndAllowThreads(__tstate);
42624 if (PyErr_Occurred()) SWIG_fail;
42625 }
42626 resultobj = SWIG_Py_Void();
42627 return resultobj;
42628 fail:
42629 return NULL;
42630 }
42631
42632
42633 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42634 PyObject *resultobj = 0;
42635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42636 size_t arg2 ;
42637 bool result;
42638 void *argp1 = 0 ;
42639 int res1 = 0 ;
42640 size_t val2 ;
42641 int ecode2 = 0 ;
42642 PyObject * obj0 = 0 ;
42643 PyObject * obj1 = 0 ;
42644 char * kwnames[] = {
42645 (char *) "self",(char *) "pos", NULL
42646 };
42647
42648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42650 if (!SWIG_IsOK(res1)) {
42651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42652 }
42653 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42654 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42655 if (!SWIG_IsOK(ecode2)) {
42656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42657 }
42658 arg2 = static_cast< size_t >(val2);
42659 {
42660 PyThreadState* __tstate = wxPyBeginAllowThreads();
42661 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42662 wxPyEndAllowThreads(__tstate);
42663 if (PyErr_Occurred()) SWIG_fail;
42664 }
42665 {
42666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42667 }
42668 return resultobj;
42669 fail:
42670 return NULL;
42671 }
42672
42673
42674 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42675 PyObject *resultobj = 0;
42676 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42677 size_t arg2 ;
42678 wxString *arg3 = 0 ;
42679 void *argp1 = 0 ;
42680 int res1 = 0 ;
42681 size_t val2 ;
42682 int ecode2 = 0 ;
42683 bool temp3 = false ;
42684 PyObject * obj0 = 0 ;
42685 PyObject * obj1 = 0 ;
42686 PyObject * obj2 = 0 ;
42687 char * kwnames[] = {
42688 (char *) "self",(char *) "pos",(char *) "label", NULL
42689 };
42690
42691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42693 if (!SWIG_IsOK(res1)) {
42694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42695 }
42696 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42697 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42698 if (!SWIG_IsOK(ecode2)) {
42699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42700 }
42701 arg2 = static_cast< size_t >(val2);
42702 {
42703 arg3 = wxString_in_helper(obj2);
42704 if (arg3 == NULL) SWIG_fail;
42705 temp3 = true;
42706 }
42707 {
42708 PyThreadState* __tstate = wxPyBeginAllowThreads();
42709 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42710 wxPyEndAllowThreads(__tstate);
42711 if (PyErr_Occurred()) SWIG_fail;
42712 }
42713 resultobj = SWIG_Py_Void();
42714 {
42715 if (temp3)
42716 delete arg3;
42717 }
42718 return resultobj;
42719 fail:
42720 {
42721 if (temp3)
42722 delete arg3;
42723 }
42724 return NULL;
42725 }
42726
42727
42728 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42729 PyObject *resultobj = 0;
42730 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42731 size_t arg2 ;
42732 wxString result;
42733 void *argp1 = 0 ;
42734 int res1 = 0 ;
42735 size_t val2 ;
42736 int ecode2 = 0 ;
42737 PyObject * obj0 = 0 ;
42738 PyObject * obj1 = 0 ;
42739 char * kwnames[] = {
42740 (char *) "self",(char *) "pos", NULL
42741 };
42742
42743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42745 if (!SWIG_IsOK(res1)) {
42746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42747 }
42748 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42749 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42750 if (!SWIG_IsOK(ecode2)) {
42751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42752 }
42753 arg2 = static_cast< size_t >(val2);
42754 {
42755 PyThreadState* __tstate = wxPyBeginAllowThreads();
42756 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42757 wxPyEndAllowThreads(__tstate);
42758 if (PyErr_Occurred()) SWIG_fail;
42759 }
42760 {
42761 #if wxUSE_UNICODE
42762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42763 #else
42764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42765 #endif
42766 }
42767 return resultobj;
42768 fail:
42769 return NULL;
42770 }
42771
42772
42773 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42774 PyObject *resultobj = 0;
42775 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42776 wxString *arg2 = 0 ;
42777 wxString *arg3 = 0 ;
42778 int result;
42779 void *argp1 = 0 ;
42780 int res1 = 0 ;
42781 bool temp2 = false ;
42782 bool temp3 = false ;
42783 PyObject * obj0 = 0 ;
42784 PyObject * obj1 = 0 ;
42785 PyObject * obj2 = 0 ;
42786 char * kwnames[] = {
42787 (char *) "self",(char *) "menu",(char *) "item", NULL
42788 };
42789
42790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42792 if (!SWIG_IsOK(res1)) {
42793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42794 }
42795 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42796 {
42797 arg2 = wxString_in_helper(obj1);
42798 if (arg2 == NULL) SWIG_fail;
42799 temp2 = true;
42800 }
42801 {
42802 arg3 = wxString_in_helper(obj2);
42803 if (arg3 == NULL) SWIG_fail;
42804 temp3 = true;
42805 }
42806 {
42807 PyThreadState* __tstate = wxPyBeginAllowThreads();
42808 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42809 wxPyEndAllowThreads(__tstate);
42810 if (PyErr_Occurred()) SWIG_fail;
42811 }
42812 resultobj = SWIG_From_int(static_cast< int >(result));
42813 {
42814 if (temp2)
42815 delete arg2;
42816 }
42817 {
42818 if (temp3)
42819 delete arg3;
42820 }
42821 return resultobj;
42822 fail:
42823 {
42824 if (temp2)
42825 delete arg2;
42826 }
42827 {
42828 if (temp3)
42829 delete arg3;
42830 }
42831 return NULL;
42832 }
42833
42834
42835 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42836 PyObject *resultobj = 0;
42837 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42838 int arg2 ;
42839 wxMenuItem *result = 0 ;
42840 void *argp1 = 0 ;
42841 int res1 = 0 ;
42842 int val2 ;
42843 int ecode2 = 0 ;
42844 PyObject * obj0 = 0 ;
42845 PyObject * obj1 = 0 ;
42846 char * kwnames[] = {
42847 (char *) "self",(char *) "id", NULL
42848 };
42849
42850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42852 if (!SWIG_IsOK(res1)) {
42853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42854 }
42855 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42856 ecode2 = SWIG_AsVal_int(obj1, &val2);
42857 if (!SWIG_IsOK(ecode2)) {
42858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42859 }
42860 arg2 = static_cast< int >(val2);
42861 {
42862 PyThreadState* __tstate = wxPyBeginAllowThreads();
42863 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42864 wxPyEndAllowThreads(__tstate);
42865 if (PyErr_Occurred()) SWIG_fail;
42866 }
42867 {
42868 resultobj = wxPyMake_wxObject(result, (bool)0);
42869 }
42870 return resultobj;
42871 fail:
42872 return NULL;
42873 }
42874
42875
42876 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42877 PyObject *resultobj = 0;
42878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42879 wxString *arg2 = 0 ;
42880 int result;
42881 void *argp1 = 0 ;
42882 int res1 = 0 ;
42883 bool temp2 = false ;
42884 PyObject * obj0 = 0 ;
42885 PyObject * obj1 = 0 ;
42886 char * kwnames[] = {
42887 (char *) "self",(char *) "title", NULL
42888 };
42889
42890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42892 if (!SWIG_IsOK(res1)) {
42893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42894 }
42895 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42896 {
42897 arg2 = wxString_in_helper(obj1);
42898 if (arg2 == NULL) SWIG_fail;
42899 temp2 = true;
42900 }
42901 {
42902 PyThreadState* __tstate = wxPyBeginAllowThreads();
42903 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42904 wxPyEndAllowThreads(__tstate);
42905 if (PyErr_Occurred()) SWIG_fail;
42906 }
42907 resultobj = SWIG_From_int(static_cast< int >(result));
42908 {
42909 if (temp2)
42910 delete arg2;
42911 }
42912 return resultobj;
42913 fail:
42914 {
42915 if (temp2)
42916 delete arg2;
42917 }
42918 return NULL;
42919 }
42920
42921
42922 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42923 PyObject *resultobj = 0;
42924 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42925 int arg2 ;
42926 bool arg3 ;
42927 void *argp1 = 0 ;
42928 int res1 = 0 ;
42929 int val2 ;
42930 int ecode2 = 0 ;
42931 bool val3 ;
42932 int ecode3 = 0 ;
42933 PyObject * obj0 = 0 ;
42934 PyObject * obj1 = 0 ;
42935 PyObject * obj2 = 0 ;
42936 char * kwnames[] = {
42937 (char *) "self",(char *) "id",(char *) "enable", NULL
42938 };
42939
42940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42942 if (!SWIG_IsOK(res1)) {
42943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42944 }
42945 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42946 ecode2 = SWIG_AsVal_int(obj1, &val2);
42947 if (!SWIG_IsOK(ecode2)) {
42948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42949 }
42950 arg2 = static_cast< int >(val2);
42951 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42952 if (!SWIG_IsOK(ecode3)) {
42953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42954 }
42955 arg3 = static_cast< bool >(val3);
42956 {
42957 PyThreadState* __tstate = wxPyBeginAllowThreads();
42958 (arg1)->Enable(arg2,arg3);
42959 wxPyEndAllowThreads(__tstate);
42960 if (PyErr_Occurred()) SWIG_fail;
42961 }
42962 resultobj = SWIG_Py_Void();
42963 return resultobj;
42964 fail:
42965 return NULL;
42966 }
42967
42968
42969 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42970 PyObject *resultobj = 0;
42971 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42972 int arg2 ;
42973 bool arg3 ;
42974 void *argp1 = 0 ;
42975 int res1 = 0 ;
42976 int val2 ;
42977 int ecode2 = 0 ;
42978 bool val3 ;
42979 int ecode3 = 0 ;
42980 PyObject * obj0 = 0 ;
42981 PyObject * obj1 = 0 ;
42982 PyObject * obj2 = 0 ;
42983 char * kwnames[] = {
42984 (char *) "self",(char *) "id",(char *) "check", NULL
42985 };
42986
42987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42989 if (!SWIG_IsOK(res1)) {
42990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42991 }
42992 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42993 ecode2 = SWIG_AsVal_int(obj1, &val2);
42994 if (!SWIG_IsOK(ecode2)) {
42995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42996 }
42997 arg2 = static_cast< int >(val2);
42998 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42999 if (!SWIG_IsOK(ecode3)) {
43000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43001 }
43002 arg3 = static_cast< bool >(val3);
43003 {
43004 PyThreadState* __tstate = wxPyBeginAllowThreads();
43005 (arg1)->Check(arg2,arg3);
43006 wxPyEndAllowThreads(__tstate);
43007 if (PyErr_Occurred()) SWIG_fail;
43008 }
43009 resultobj = SWIG_Py_Void();
43010 return resultobj;
43011 fail:
43012 return NULL;
43013 }
43014
43015
43016 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43017 PyObject *resultobj = 0;
43018 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43019 int arg2 ;
43020 bool result;
43021 void *argp1 = 0 ;
43022 int res1 = 0 ;
43023 int val2 ;
43024 int ecode2 = 0 ;
43025 PyObject * obj0 = 0 ;
43026 PyObject * obj1 = 0 ;
43027 char * kwnames[] = {
43028 (char *) "self",(char *) "id", NULL
43029 };
43030
43031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43033 if (!SWIG_IsOK(res1)) {
43034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43035 }
43036 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43037 ecode2 = SWIG_AsVal_int(obj1, &val2);
43038 if (!SWIG_IsOK(ecode2)) {
43039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43040 }
43041 arg2 = static_cast< int >(val2);
43042 {
43043 PyThreadState* __tstate = wxPyBeginAllowThreads();
43044 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43045 wxPyEndAllowThreads(__tstate);
43046 if (PyErr_Occurred()) SWIG_fail;
43047 }
43048 {
43049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43050 }
43051 return resultobj;
43052 fail:
43053 return NULL;
43054 }
43055
43056
43057 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43058 PyObject *resultobj = 0;
43059 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43060 int arg2 ;
43061 bool result;
43062 void *argp1 = 0 ;
43063 int res1 = 0 ;
43064 int val2 ;
43065 int ecode2 = 0 ;
43066 PyObject * obj0 = 0 ;
43067 PyObject * obj1 = 0 ;
43068 char * kwnames[] = {
43069 (char *) "self",(char *) "id", NULL
43070 };
43071
43072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43074 if (!SWIG_IsOK(res1)) {
43075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43076 }
43077 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43078 ecode2 = SWIG_AsVal_int(obj1, &val2);
43079 if (!SWIG_IsOK(ecode2)) {
43080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43081 }
43082 arg2 = static_cast< int >(val2);
43083 {
43084 PyThreadState* __tstate = wxPyBeginAllowThreads();
43085 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43086 wxPyEndAllowThreads(__tstate);
43087 if (PyErr_Occurred()) SWIG_fail;
43088 }
43089 {
43090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43091 }
43092 return resultobj;
43093 fail:
43094 return NULL;
43095 }
43096
43097
43098 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43099 PyObject *resultobj = 0;
43100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43101 int arg2 ;
43102 wxString *arg3 = 0 ;
43103 void *argp1 = 0 ;
43104 int res1 = 0 ;
43105 int val2 ;
43106 int ecode2 = 0 ;
43107 bool temp3 = false ;
43108 PyObject * obj0 = 0 ;
43109 PyObject * obj1 = 0 ;
43110 PyObject * obj2 = 0 ;
43111 char * kwnames[] = {
43112 (char *) "self",(char *) "id",(char *) "label", NULL
43113 };
43114
43115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43117 if (!SWIG_IsOK(res1)) {
43118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43119 }
43120 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43121 ecode2 = SWIG_AsVal_int(obj1, &val2);
43122 if (!SWIG_IsOK(ecode2)) {
43123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43124 }
43125 arg2 = static_cast< int >(val2);
43126 {
43127 arg3 = wxString_in_helper(obj2);
43128 if (arg3 == NULL) SWIG_fail;
43129 temp3 = true;
43130 }
43131 {
43132 PyThreadState* __tstate = wxPyBeginAllowThreads();
43133 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43134 wxPyEndAllowThreads(__tstate);
43135 if (PyErr_Occurred()) SWIG_fail;
43136 }
43137 resultobj = SWIG_Py_Void();
43138 {
43139 if (temp3)
43140 delete arg3;
43141 }
43142 return resultobj;
43143 fail:
43144 {
43145 if (temp3)
43146 delete arg3;
43147 }
43148 return NULL;
43149 }
43150
43151
43152 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43153 PyObject *resultobj = 0;
43154 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43155 int arg2 ;
43156 wxString result;
43157 void *argp1 = 0 ;
43158 int res1 = 0 ;
43159 int val2 ;
43160 int ecode2 = 0 ;
43161 PyObject * obj0 = 0 ;
43162 PyObject * obj1 = 0 ;
43163 char * kwnames[] = {
43164 (char *) "self",(char *) "id", NULL
43165 };
43166
43167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43169 if (!SWIG_IsOK(res1)) {
43170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43171 }
43172 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43173 ecode2 = SWIG_AsVal_int(obj1, &val2);
43174 if (!SWIG_IsOK(ecode2)) {
43175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43176 }
43177 arg2 = static_cast< int >(val2);
43178 {
43179 PyThreadState* __tstate = wxPyBeginAllowThreads();
43180 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43181 wxPyEndAllowThreads(__tstate);
43182 if (PyErr_Occurred()) SWIG_fail;
43183 }
43184 {
43185 #if wxUSE_UNICODE
43186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43187 #else
43188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43189 #endif
43190 }
43191 return resultobj;
43192 fail:
43193 return NULL;
43194 }
43195
43196
43197 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43198 PyObject *resultobj = 0;
43199 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43200 int arg2 ;
43201 wxString *arg3 = 0 ;
43202 void *argp1 = 0 ;
43203 int res1 = 0 ;
43204 int val2 ;
43205 int ecode2 = 0 ;
43206 bool temp3 = false ;
43207 PyObject * obj0 = 0 ;
43208 PyObject * obj1 = 0 ;
43209 PyObject * obj2 = 0 ;
43210 char * kwnames[] = {
43211 (char *) "self",(char *) "id",(char *) "helpString", NULL
43212 };
43213
43214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43216 if (!SWIG_IsOK(res1)) {
43217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43218 }
43219 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43220 ecode2 = SWIG_AsVal_int(obj1, &val2);
43221 if (!SWIG_IsOK(ecode2)) {
43222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43223 }
43224 arg2 = static_cast< int >(val2);
43225 {
43226 arg3 = wxString_in_helper(obj2);
43227 if (arg3 == NULL) SWIG_fail;
43228 temp3 = true;
43229 }
43230 {
43231 PyThreadState* __tstate = wxPyBeginAllowThreads();
43232 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43233 wxPyEndAllowThreads(__tstate);
43234 if (PyErr_Occurred()) SWIG_fail;
43235 }
43236 resultobj = SWIG_Py_Void();
43237 {
43238 if (temp3)
43239 delete arg3;
43240 }
43241 return resultobj;
43242 fail:
43243 {
43244 if (temp3)
43245 delete arg3;
43246 }
43247 return NULL;
43248 }
43249
43250
43251 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43252 PyObject *resultobj = 0;
43253 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43254 int arg2 ;
43255 wxString result;
43256 void *argp1 = 0 ;
43257 int res1 = 0 ;
43258 int val2 ;
43259 int ecode2 = 0 ;
43260 PyObject * obj0 = 0 ;
43261 PyObject * obj1 = 0 ;
43262 char * kwnames[] = {
43263 (char *) "self",(char *) "id", NULL
43264 };
43265
43266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43268 if (!SWIG_IsOK(res1)) {
43269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43270 }
43271 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43272 ecode2 = SWIG_AsVal_int(obj1, &val2);
43273 if (!SWIG_IsOK(ecode2)) {
43274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43275 }
43276 arg2 = static_cast< int >(val2);
43277 {
43278 PyThreadState* __tstate = wxPyBeginAllowThreads();
43279 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43280 wxPyEndAllowThreads(__tstate);
43281 if (PyErr_Occurred()) SWIG_fail;
43282 }
43283 {
43284 #if wxUSE_UNICODE
43285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43286 #else
43287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43288 #endif
43289 }
43290 return resultobj;
43291 fail:
43292 return NULL;
43293 }
43294
43295
43296 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43297 PyObject *resultobj = 0;
43298 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43299 wxFrame *result = 0 ;
43300 void *argp1 = 0 ;
43301 int res1 = 0 ;
43302 PyObject *swig_obj[1] ;
43303
43304 if (!args) SWIG_fail;
43305 swig_obj[0] = args;
43306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43307 if (!SWIG_IsOK(res1)) {
43308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43309 }
43310 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43311 {
43312 PyThreadState* __tstate = wxPyBeginAllowThreads();
43313 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43314 wxPyEndAllowThreads(__tstate);
43315 if (PyErr_Occurred()) SWIG_fail;
43316 }
43317 {
43318 resultobj = wxPyMake_wxObject(result, (bool)0);
43319 }
43320 return resultobj;
43321 fail:
43322 return NULL;
43323 }
43324
43325
43326 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43327 PyObject *resultobj = 0;
43328 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43329 bool result;
43330 void *argp1 = 0 ;
43331 int res1 = 0 ;
43332 PyObject *swig_obj[1] ;
43333
43334 if (!args) SWIG_fail;
43335 swig_obj[0] = args;
43336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43337 if (!SWIG_IsOK(res1)) {
43338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43339 }
43340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43341 {
43342 PyThreadState* __tstate = wxPyBeginAllowThreads();
43343 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 {
43348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43349 }
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43357 PyObject *resultobj = 0;
43358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43359 wxFrame *arg2 = (wxFrame *) 0 ;
43360 void *argp1 = 0 ;
43361 int res1 = 0 ;
43362 void *argp2 = 0 ;
43363 int res2 = 0 ;
43364 PyObject * obj0 = 0 ;
43365 PyObject * obj1 = 0 ;
43366 char * kwnames[] = {
43367 (char *) "self",(char *) "frame", NULL
43368 };
43369
43370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43372 if (!SWIG_IsOK(res1)) {
43373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43374 }
43375 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43377 if (!SWIG_IsOK(res2)) {
43378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43379 }
43380 arg2 = reinterpret_cast< wxFrame * >(argp2);
43381 {
43382 PyThreadState* __tstate = wxPyBeginAllowThreads();
43383 (arg1)->Attach(arg2);
43384 wxPyEndAllowThreads(__tstate);
43385 if (PyErr_Occurred()) SWIG_fail;
43386 }
43387 resultobj = SWIG_Py_Void();
43388 return resultobj;
43389 fail:
43390 return NULL;
43391 }
43392
43393
43394 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43395 PyObject *resultobj = 0;
43396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43397 void *argp1 = 0 ;
43398 int res1 = 0 ;
43399 PyObject *swig_obj[1] ;
43400
43401 if (!args) SWIG_fail;
43402 swig_obj[0] = args;
43403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43404 if (!SWIG_IsOK(res1)) {
43405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43406 }
43407 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43408 {
43409 PyThreadState* __tstate = wxPyBeginAllowThreads();
43410 (arg1)->Detach();
43411 wxPyEndAllowThreads(__tstate);
43412 if (PyErr_Occurred()) SWIG_fail;
43413 }
43414 resultobj = SWIG_Py_Void();
43415 return resultobj;
43416 fail:
43417 return NULL;
43418 }
43419
43420
43421 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43422 PyObject *resultobj = 0;
43423 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43424 void *argp1 = 0 ;
43425 int res1 = 0 ;
43426 PyObject *swig_obj[1] ;
43427
43428 if (!args) SWIG_fail;
43429 swig_obj[0] = args;
43430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43431 if (!SWIG_IsOK(res1)) {
43432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43433 }
43434 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 (arg1)->UpdateMenus();
43438 wxPyEndAllowThreads(__tstate);
43439 if (PyErr_Occurred()) SWIG_fail;
43440 }
43441 resultobj = SWIG_Py_Void();
43442 return resultobj;
43443 fail:
43444 return NULL;
43445 }
43446
43447
43448 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43449 PyObject *resultobj = 0;
43450 bool arg1 ;
43451 bool val1 ;
43452 int ecode1 = 0 ;
43453 PyObject * obj0 = 0 ;
43454 char * kwnames[] = {
43455 (char *) "enable", NULL
43456 };
43457
43458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43459 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43460 if (!SWIG_IsOK(ecode1)) {
43461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43462 }
43463 arg1 = static_cast< bool >(val1);
43464 {
43465 PyThreadState* __tstate = wxPyBeginAllowThreads();
43466 wxMenuBar::SetAutoWindowMenu(arg1);
43467 wxPyEndAllowThreads(__tstate);
43468 if (PyErr_Occurred()) SWIG_fail;
43469 }
43470 resultobj = SWIG_Py_Void();
43471 return resultobj;
43472 fail:
43473 return NULL;
43474 }
43475
43476
43477 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43478 PyObject *resultobj = 0;
43479 bool result;
43480
43481 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43482 {
43483 PyThreadState* __tstate = wxPyBeginAllowThreads();
43484 result = (bool)wxMenuBar::GetAutoWindowMenu();
43485 wxPyEndAllowThreads(__tstate);
43486 if (PyErr_Occurred()) SWIG_fail;
43487 }
43488 {
43489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43490 }
43491 return resultobj;
43492 fail:
43493 return NULL;
43494 }
43495
43496
43497 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43498 PyObject *obj;
43499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43500 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43501 return SWIG_Py_Void();
43502 }
43503
43504 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43505 return SWIG_Python_InitShadowInstance(args);
43506 }
43507
43508 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj = 0;
43510 wxMenu *arg1 = (wxMenu *) NULL ;
43511 int arg2 = (int) wxID_ANY ;
43512 wxString const &arg3_defvalue = wxPyEmptyString ;
43513 wxString *arg3 = (wxString *) &arg3_defvalue ;
43514 wxString const &arg4_defvalue = wxPyEmptyString ;
43515 wxString *arg4 = (wxString *) &arg4_defvalue ;
43516 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43517 wxMenu *arg6 = (wxMenu *) NULL ;
43518 wxMenuItem *result = 0 ;
43519 void *argp1 = 0 ;
43520 int res1 = 0 ;
43521 int val2 ;
43522 int ecode2 = 0 ;
43523 bool temp3 = false ;
43524 bool temp4 = false ;
43525 int val5 ;
43526 int ecode5 = 0 ;
43527 void *argp6 = 0 ;
43528 int res6 = 0 ;
43529 PyObject * obj0 = 0 ;
43530 PyObject * obj1 = 0 ;
43531 PyObject * obj2 = 0 ;
43532 PyObject * obj3 = 0 ;
43533 PyObject * obj4 = 0 ;
43534 PyObject * obj5 = 0 ;
43535 char * kwnames[] = {
43536 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43537 };
43538
43539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43540 if (obj0) {
43541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43542 if (!SWIG_IsOK(res1)) {
43543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43544 }
43545 arg1 = reinterpret_cast< wxMenu * >(argp1);
43546 }
43547 if (obj1) {
43548 ecode2 = SWIG_AsVal_int(obj1, &val2);
43549 if (!SWIG_IsOK(ecode2)) {
43550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43551 }
43552 arg2 = static_cast< int >(val2);
43553 }
43554 if (obj2) {
43555 {
43556 arg3 = wxString_in_helper(obj2);
43557 if (arg3 == NULL) SWIG_fail;
43558 temp3 = true;
43559 }
43560 }
43561 if (obj3) {
43562 {
43563 arg4 = wxString_in_helper(obj3);
43564 if (arg4 == NULL) SWIG_fail;
43565 temp4 = true;
43566 }
43567 }
43568 if (obj4) {
43569 ecode5 = SWIG_AsVal_int(obj4, &val5);
43570 if (!SWIG_IsOK(ecode5)) {
43571 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43572 }
43573 arg5 = static_cast< wxItemKind >(val5);
43574 }
43575 if (obj5) {
43576 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43577 if (!SWIG_IsOK(res6)) {
43578 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43579 }
43580 arg6 = reinterpret_cast< wxMenu * >(argp6);
43581 }
43582 {
43583 PyThreadState* __tstate = wxPyBeginAllowThreads();
43584 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43585 wxPyEndAllowThreads(__tstate);
43586 if (PyErr_Occurred()) SWIG_fail;
43587 }
43588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
43589 {
43590 if (temp3)
43591 delete arg3;
43592 }
43593 {
43594 if (temp4)
43595 delete arg4;
43596 }
43597 return resultobj;
43598 fail:
43599 {
43600 if (temp3)
43601 delete arg3;
43602 }
43603 {
43604 if (temp4)
43605 delete arg4;
43606 }
43607 return NULL;
43608 }
43609
43610
43611 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43612 PyObject *resultobj = 0;
43613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43614 void *argp1 = 0 ;
43615 int res1 = 0 ;
43616 PyObject *swig_obj[1] ;
43617
43618 if (!args) SWIG_fail;
43619 swig_obj[0] = args;
43620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43621 if (!SWIG_IsOK(res1)) {
43622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43623 }
43624 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43625 {
43626 PyThreadState* __tstate = wxPyBeginAllowThreads();
43627 delete arg1;
43628
43629 wxPyEndAllowThreads(__tstate);
43630 if (PyErr_Occurred()) SWIG_fail;
43631 }
43632 resultobj = SWIG_Py_Void();
43633 return resultobj;
43634 fail:
43635 return NULL;
43636 }
43637
43638
43639 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43640 PyObject *resultobj = 0;
43641 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43642 wxMenu *result = 0 ;
43643 void *argp1 = 0 ;
43644 int res1 = 0 ;
43645 PyObject *swig_obj[1] ;
43646
43647 if (!args) SWIG_fail;
43648 swig_obj[0] = args;
43649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43650 if (!SWIG_IsOK(res1)) {
43651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43652 }
43653 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43654 {
43655 PyThreadState* __tstate = wxPyBeginAllowThreads();
43656 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43657 wxPyEndAllowThreads(__tstate);
43658 if (PyErr_Occurred()) SWIG_fail;
43659 }
43660 {
43661 resultobj = wxPyMake_wxObject(result, 0);
43662 }
43663 return resultobj;
43664 fail:
43665 return NULL;
43666 }
43667
43668
43669 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43670 PyObject *resultobj = 0;
43671 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43672 wxMenu *arg2 = (wxMenu *) 0 ;
43673 void *argp1 = 0 ;
43674 int res1 = 0 ;
43675 void *argp2 = 0 ;
43676 int res2 = 0 ;
43677 PyObject * obj0 = 0 ;
43678 PyObject * obj1 = 0 ;
43679 char * kwnames[] = {
43680 (char *) "self",(char *) "menu", NULL
43681 };
43682
43683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43685 if (!SWIG_IsOK(res1)) {
43686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43687 }
43688 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43690 if (!SWIG_IsOK(res2)) {
43691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43692 }
43693 arg2 = reinterpret_cast< wxMenu * >(argp2);
43694 {
43695 PyThreadState* __tstate = wxPyBeginAllowThreads();
43696 (arg1)->SetMenu(arg2);
43697 wxPyEndAllowThreads(__tstate);
43698 if (PyErr_Occurred()) SWIG_fail;
43699 }
43700 resultobj = SWIG_Py_Void();
43701 return resultobj;
43702 fail:
43703 return NULL;
43704 }
43705
43706
43707 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43708 PyObject *resultobj = 0;
43709 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43710 int arg2 ;
43711 void *argp1 = 0 ;
43712 int res1 = 0 ;
43713 int val2 ;
43714 int ecode2 = 0 ;
43715 PyObject * obj0 = 0 ;
43716 PyObject * obj1 = 0 ;
43717 char * kwnames[] = {
43718 (char *) "self",(char *) "id", NULL
43719 };
43720
43721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43723 if (!SWIG_IsOK(res1)) {
43724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43725 }
43726 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43727 ecode2 = SWIG_AsVal_int(obj1, &val2);
43728 if (!SWIG_IsOK(ecode2)) {
43729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43730 }
43731 arg2 = static_cast< int >(val2);
43732 {
43733 PyThreadState* __tstate = wxPyBeginAllowThreads();
43734 (arg1)->SetId(arg2);
43735 wxPyEndAllowThreads(__tstate);
43736 if (PyErr_Occurred()) SWIG_fail;
43737 }
43738 resultobj = SWIG_Py_Void();
43739 return resultobj;
43740 fail:
43741 return NULL;
43742 }
43743
43744
43745 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43746 PyObject *resultobj = 0;
43747 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43748 int result;
43749 void *argp1 = 0 ;
43750 int res1 = 0 ;
43751 PyObject *swig_obj[1] ;
43752
43753 if (!args) SWIG_fail;
43754 swig_obj[0] = args;
43755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43756 if (!SWIG_IsOK(res1)) {
43757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43758 }
43759 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43760 {
43761 PyThreadState* __tstate = wxPyBeginAllowThreads();
43762 result = (int)((wxMenuItem const *)arg1)->GetId();
43763 wxPyEndAllowThreads(__tstate);
43764 if (PyErr_Occurred()) SWIG_fail;
43765 }
43766 resultobj = SWIG_From_int(static_cast< int >(result));
43767 return resultobj;
43768 fail:
43769 return NULL;
43770 }
43771
43772
43773 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43774 PyObject *resultobj = 0;
43775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43776 bool result;
43777 void *argp1 = 0 ;
43778 int res1 = 0 ;
43779 PyObject *swig_obj[1] ;
43780
43781 if (!args) SWIG_fail;
43782 swig_obj[0] = args;
43783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43784 if (!SWIG_IsOK(res1)) {
43785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43786 }
43787 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43788 {
43789 PyThreadState* __tstate = wxPyBeginAllowThreads();
43790 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43791 wxPyEndAllowThreads(__tstate);
43792 if (PyErr_Occurred()) SWIG_fail;
43793 }
43794 {
43795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43796 }
43797 return resultobj;
43798 fail:
43799 return NULL;
43800 }
43801
43802
43803 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43804 PyObject *resultobj = 0;
43805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43806 wxString *arg2 = 0 ;
43807 void *argp1 = 0 ;
43808 int res1 = 0 ;
43809 bool temp2 = false ;
43810 PyObject * obj0 = 0 ;
43811 PyObject * obj1 = 0 ;
43812 char * kwnames[] = {
43813 (char *) "self",(char *) "str", NULL
43814 };
43815
43816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43818 if (!SWIG_IsOK(res1)) {
43819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43820 }
43821 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43822 {
43823 arg2 = wxString_in_helper(obj1);
43824 if (arg2 == NULL) SWIG_fail;
43825 temp2 = true;
43826 }
43827 {
43828 PyThreadState* __tstate = wxPyBeginAllowThreads();
43829 (arg1)->SetText((wxString const &)*arg2);
43830 wxPyEndAllowThreads(__tstate);
43831 if (PyErr_Occurred()) SWIG_fail;
43832 }
43833 resultobj = SWIG_Py_Void();
43834 {
43835 if (temp2)
43836 delete arg2;
43837 }
43838 return resultobj;
43839 fail:
43840 {
43841 if (temp2)
43842 delete arg2;
43843 }
43844 return NULL;
43845 }
43846
43847
43848 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43849 PyObject *resultobj = 0;
43850 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43851 wxString result;
43852 void *argp1 = 0 ;
43853 int res1 = 0 ;
43854 PyObject *swig_obj[1] ;
43855
43856 if (!args) SWIG_fail;
43857 swig_obj[0] = args;
43858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43859 if (!SWIG_IsOK(res1)) {
43860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43861 }
43862 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43863 {
43864 PyThreadState* __tstate = wxPyBeginAllowThreads();
43865 result = ((wxMenuItem const *)arg1)->GetLabel();
43866 wxPyEndAllowThreads(__tstate);
43867 if (PyErr_Occurred()) SWIG_fail;
43868 }
43869 {
43870 #if wxUSE_UNICODE
43871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43872 #else
43873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43874 #endif
43875 }
43876 return resultobj;
43877 fail:
43878 return NULL;
43879 }
43880
43881
43882 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43883 PyObject *resultobj = 0;
43884 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43885 wxString *result = 0 ;
43886 void *argp1 = 0 ;
43887 int res1 = 0 ;
43888 PyObject *swig_obj[1] ;
43889
43890 if (!args) SWIG_fail;
43891 swig_obj[0] = args;
43892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43893 if (!SWIG_IsOK(res1)) {
43894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43895 }
43896 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43897 {
43898 PyThreadState* __tstate = wxPyBeginAllowThreads();
43899 {
43900 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43901 result = (wxString *) &_result_ref;
43902 }
43903 wxPyEndAllowThreads(__tstate);
43904 if (PyErr_Occurred()) SWIG_fail;
43905 }
43906 {
43907 #if wxUSE_UNICODE
43908 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43909 #else
43910 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43911 #endif
43912 }
43913 return resultobj;
43914 fail:
43915 return NULL;
43916 }
43917
43918
43919 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43920 PyObject *resultobj = 0;
43921 wxString *arg1 = 0 ;
43922 wxString result;
43923 bool temp1 = false ;
43924 PyObject * obj0 = 0 ;
43925 char * kwnames[] = {
43926 (char *) "text", NULL
43927 };
43928
43929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43930 {
43931 arg1 = wxString_in_helper(obj0);
43932 if (arg1 == NULL) SWIG_fail;
43933 temp1 = true;
43934 }
43935 {
43936 PyThreadState* __tstate = wxPyBeginAllowThreads();
43937 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43938 wxPyEndAllowThreads(__tstate);
43939 if (PyErr_Occurred()) SWIG_fail;
43940 }
43941 {
43942 #if wxUSE_UNICODE
43943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43944 #else
43945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43946 #endif
43947 }
43948 {
43949 if (temp1)
43950 delete arg1;
43951 }
43952 return resultobj;
43953 fail:
43954 {
43955 if (temp1)
43956 delete arg1;
43957 }
43958 return NULL;
43959 }
43960
43961
43962 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43963 PyObject *resultobj = 0;
43964 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43965 wxItemKind result;
43966 void *argp1 = 0 ;
43967 int res1 = 0 ;
43968 PyObject *swig_obj[1] ;
43969
43970 if (!args) SWIG_fail;
43971 swig_obj[0] = args;
43972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43973 if (!SWIG_IsOK(res1)) {
43974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43975 }
43976 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43977 {
43978 PyThreadState* __tstate = wxPyBeginAllowThreads();
43979 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43980 wxPyEndAllowThreads(__tstate);
43981 if (PyErr_Occurred()) SWIG_fail;
43982 }
43983 resultobj = SWIG_From_int(static_cast< int >(result));
43984 return resultobj;
43985 fail:
43986 return NULL;
43987 }
43988
43989
43990 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43991 PyObject *resultobj = 0;
43992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43993 wxItemKind arg2 ;
43994 void *argp1 = 0 ;
43995 int res1 = 0 ;
43996 int val2 ;
43997 int ecode2 = 0 ;
43998 PyObject * obj0 = 0 ;
43999 PyObject * obj1 = 0 ;
44000 char * kwnames[] = {
44001 (char *) "self",(char *) "kind", NULL
44002 };
44003
44004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44006 if (!SWIG_IsOK(res1)) {
44007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44008 }
44009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44010 ecode2 = SWIG_AsVal_int(obj1, &val2);
44011 if (!SWIG_IsOK(ecode2)) {
44012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44013 }
44014 arg2 = static_cast< wxItemKind >(val2);
44015 {
44016 PyThreadState* __tstate = wxPyBeginAllowThreads();
44017 (arg1)->SetKind(arg2);
44018 wxPyEndAllowThreads(__tstate);
44019 if (PyErr_Occurred()) SWIG_fail;
44020 }
44021 resultobj = SWIG_Py_Void();
44022 return resultobj;
44023 fail:
44024 return NULL;
44025 }
44026
44027
44028 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44029 PyObject *resultobj = 0;
44030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44031 bool arg2 ;
44032 void *argp1 = 0 ;
44033 int res1 = 0 ;
44034 bool val2 ;
44035 int ecode2 = 0 ;
44036 PyObject * obj0 = 0 ;
44037 PyObject * obj1 = 0 ;
44038 char * kwnames[] = {
44039 (char *) "self",(char *) "checkable", NULL
44040 };
44041
44042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44044 if (!SWIG_IsOK(res1)) {
44045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44046 }
44047 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44048 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44049 if (!SWIG_IsOK(ecode2)) {
44050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44051 }
44052 arg2 = static_cast< bool >(val2);
44053 {
44054 PyThreadState* __tstate = wxPyBeginAllowThreads();
44055 (arg1)->SetCheckable(arg2);
44056 wxPyEndAllowThreads(__tstate);
44057 if (PyErr_Occurred()) SWIG_fail;
44058 }
44059 resultobj = SWIG_Py_Void();
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44067 PyObject *resultobj = 0;
44068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44069 bool result;
44070 void *argp1 = 0 ;
44071 int res1 = 0 ;
44072 PyObject *swig_obj[1] ;
44073
44074 if (!args) SWIG_fail;
44075 swig_obj[0] = args;
44076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44077 if (!SWIG_IsOK(res1)) {
44078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44079 }
44080 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44081 {
44082 PyThreadState* __tstate = wxPyBeginAllowThreads();
44083 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44084 wxPyEndAllowThreads(__tstate);
44085 if (PyErr_Occurred()) SWIG_fail;
44086 }
44087 {
44088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44089 }
44090 return resultobj;
44091 fail:
44092 return NULL;
44093 }
44094
44095
44096 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44097 PyObject *resultobj = 0;
44098 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44099 bool result;
44100 void *argp1 = 0 ;
44101 int res1 = 0 ;
44102 PyObject *swig_obj[1] ;
44103
44104 if (!args) SWIG_fail;
44105 swig_obj[0] = args;
44106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44107 if (!SWIG_IsOK(res1)) {
44108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44109 }
44110 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44111 {
44112 PyThreadState* __tstate = wxPyBeginAllowThreads();
44113 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44114 wxPyEndAllowThreads(__tstate);
44115 if (PyErr_Occurred()) SWIG_fail;
44116 }
44117 {
44118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44119 }
44120 return resultobj;
44121 fail:
44122 return NULL;
44123 }
44124
44125
44126 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44127 PyObject *resultobj = 0;
44128 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44129 wxMenu *arg2 = (wxMenu *) 0 ;
44130 void *argp1 = 0 ;
44131 int res1 = 0 ;
44132 void *argp2 = 0 ;
44133 int res2 = 0 ;
44134 PyObject * obj0 = 0 ;
44135 PyObject * obj1 = 0 ;
44136 char * kwnames[] = {
44137 (char *) "self",(char *) "menu", NULL
44138 };
44139
44140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44142 if (!SWIG_IsOK(res1)) {
44143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44144 }
44145 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44146 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44147 if (!SWIG_IsOK(res2)) {
44148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44149 }
44150 arg2 = reinterpret_cast< wxMenu * >(argp2);
44151 {
44152 PyThreadState* __tstate = wxPyBeginAllowThreads();
44153 (arg1)->SetSubMenu(arg2);
44154 wxPyEndAllowThreads(__tstate);
44155 if (PyErr_Occurred()) SWIG_fail;
44156 }
44157 resultobj = SWIG_Py_Void();
44158 return resultobj;
44159 fail:
44160 return NULL;
44161 }
44162
44163
44164 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44165 PyObject *resultobj = 0;
44166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44167 wxMenu *result = 0 ;
44168 void *argp1 = 0 ;
44169 int res1 = 0 ;
44170 PyObject *swig_obj[1] ;
44171
44172 if (!args) SWIG_fail;
44173 swig_obj[0] = args;
44174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44175 if (!SWIG_IsOK(res1)) {
44176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44177 }
44178 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44179 {
44180 PyThreadState* __tstate = wxPyBeginAllowThreads();
44181 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44182 wxPyEndAllowThreads(__tstate);
44183 if (PyErr_Occurred()) SWIG_fail;
44184 }
44185 {
44186 resultobj = wxPyMake_wxObject(result, 0);
44187 }
44188 return resultobj;
44189 fail:
44190 return NULL;
44191 }
44192
44193
44194 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44195 PyObject *resultobj = 0;
44196 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44197 bool arg2 = (bool) true ;
44198 void *argp1 = 0 ;
44199 int res1 = 0 ;
44200 bool val2 ;
44201 int ecode2 = 0 ;
44202 PyObject * obj0 = 0 ;
44203 PyObject * obj1 = 0 ;
44204 char * kwnames[] = {
44205 (char *) "self",(char *) "enable", NULL
44206 };
44207
44208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44210 if (!SWIG_IsOK(res1)) {
44211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44212 }
44213 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44214 if (obj1) {
44215 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44216 if (!SWIG_IsOK(ecode2)) {
44217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44218 }
44219 arg2 = static_cast< bool >(val2);
44220 }
44221 {
44222 PyThreadState* __tstate = wxPyBeginAllowThreads();
44223 (arg1)->Enable(arg2);
44224 wxPyEndAllowThreads(__tstate);
44225 if (PyErr_Occurred()) SWIG_fail;
44226 }
44227 resultobj = SWIG_Py_Void();
44228 return resultobj;
44229 fail:
44230 return NULL;
44231 }
44232
44233
44234 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44235 PyObject *resultobj = 0;
44236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44237 bool result;
44238 void *argp1 = 0 ;
44239 int res1 = 0 ;
44240 PyObject *swig_obj[1] ;
44241
44242 if (!args) SWIG_fail;
44243 swig_obj[0] = args;
44244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44245 if (!SWIG_IsOK(res1)) {
44246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44247 }
44248 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44249 {
44250 PyThreadState* __tstate = wxPyBeginAllowThreads();
44251 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44252 wxPyEndAllowThreads(__tstate);
44253 if (PyErr_Occurred()) SWIG_fail;
44254 }
44255 {
44256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44257 }
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44265 PyObject *resultobj = 0;
44266 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44267 bool arg2 = (bool) true ;
44268 void *argp1 = 0 ;
44269 int res1 = 0 ;
44270 bool val2 ;
44271 int ecode2 = 0 ;
44272 PyObject * obj0 = 0 ;
44273 PyObject * obj1 = 0 ;
44274 char * kwnames[] = {
44275 (char *) "self",(char *) "check", NULL
44276 };
44277
44278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44280 if (!SWIG_IsOK(res1)) {
44281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44282 }
44283 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44284 if (obj1) {
44285 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44286 if (!SWIG_IsOK(ecode2)) {
44287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44288 }
44289 arg2 = static_cast< bool >(val2);
44290 }
44291 {
44292 PyThreadState* __tstate = wxPyBeginAllowThreads();
44293 (arg1)->Check(arg2);
44294 wxPyEndAllowThreads(__tstate);
44295 if (PyErr_Occurred()) SWIG_fail;
44296 }
44297 resultobj = SWIG_Py_Void();
44298 return resultobj;
44299 fail:
44300 return NULL;
44301 }
44302
44303
44304 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44305 PyObject *resultobj = 0;
44306 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44307 bool result;
44308 void *argp1 = 0 ;
44309 int res1 = 0 ;
44310 PyObject *swig_obj[1] ;
44311
44312 if (!args) SWIG_fail;
44313 swig_obj[0] = args;
44314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44315 if (!SWIG_IsOK(res1)) {
44316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44317 }
44318 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44319 {
44320 PyThreadState* __tstate = wxPyBeginAllowThreads();
44321 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44322 wxPyEndAllowThreads(__tstate);
44323 if (PyErr_Occurred()) SWIG_fail;
44324 }
44325 {
44326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44327 }
44328 return resultobj;
44329 fail:
44330 return NULL;
44331 }
44332
44333
44334 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44335 PyObject *resultobj = 0;
44336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44337 void *argp1 = 0 ;
44338 int res1 = 0 ;
44339 PyObject *swig_obj[1] ;
44340
44341 if (!args) SWIG_fail;
44342 swig_obj[0] = args;
44343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44344 if (!SWIG_IsOK(res1)) {
44345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44346 }
44347 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44348 {
44349 PyThreadState* __tstate = wxPyBeginAllowThreads();
44350 (arg1)->Toggle();
44351 wxPyEndAllowThreads(__tstate);
44352 if (PyErr_Occurred()) SWIG_fail;
44353 }
44354 resultobj = SWIG_Py_Void();
44355 return resultobj;
44356 fail:
44357 return NULL;
44358 }
44359
44360
44361 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44362 PyObject *resultobj = 0;
44363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44364 wxString *arg2 = 0 ;
44365 void *argp1 = 0 ;
44366 int res1 = 0 ;
44367 bool temp2 = false ;
44368 PyObject * obj0 = 0 ;
44369 PyObject * obj1 = 0 ;
44370 char * kwnames[] = {
44371 (char *) "self",(char *) "str", NULL
44372 };
44373
44374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44380 {
44381 arg2 = wxString_in_helper(obj1);
44382 if (arg2 == NULL) SWIG_fail;
44383 temp2 = true;
44384 }
44385 {
44386 PyThreadState* __tstate = wxPyBeginAllowThreads();
44387 (arg1)->SetHelp((wxString const &)*arg2);
44388 wxPyEndAllowThreads(__tstate);
44389 if (PyErr_Occurred()) SWIG_fail;
44390 }
44391 resultobj = SWIG_Py_Void();
44392 {
44393 if (temp2)
44394 delete arg2;
44395 }
44396 return resultobj;
44397 fail:
44398 {
44399 if (temp2)
44400 delete arg2;
44401 }
44402 return NULL;
44403 }
44404
44405
44406 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44407 PyObject *resultobj = 0;
44408 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44409 wxString *result = 0 ;
44410 void *argp1 = 0 ;
44411 int res1 = 0 ;
44412 PyObject *swig_obj[1] ;
44413
44414 if (!args) SWIG_fail;
44415 swig_obj[0] = args;
44416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44417 if (!SWIG_IsOK(res1)) {
44418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44419 }
44420 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44421 {
44422 PyThreadState* __tstate = wxPyBeginAllowThreads();
44423 {
44424 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44425 result = (wxString *) &_result_ref;
44426 }
44427 wxPyEndAllowThreads(__tstate);
44428 if (PyErr_Occurred()) SWIG_fail;
44429 }
44430 {
44431 #if wxUSE_UNICODE
44432 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44433 #else
44434 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44435 #endif
44436 }
44437 return resultobj;
44438 fail:
44439 return NULL;
44440 }
44441
44442
44443 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44444 PyObject *resultobj = 0;
44445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44446 wxAcceleratorEntry *result = 0 ;
44447 void *argp1 = 0 ;
44448 int res1 = 0 ;
44449 PyObject *swig_obj[1] ;
44450
44451 if (!args) SWIG_fail;
44452 swig_obj[0] = args;
44453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44454 if (!SWIG_IsOK(res1)) {
44455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44456 }
44457 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44458 {
44459 PyThreadState* __tstate = wxPyBeginAllowThreads();
44460 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44461 wxPyEndAllowThreads(__tstate);
44462 if (PyErr_Occurred()) SWIG_fail;
44463 }
44464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44465 return resultobj;
44466 fail:
44467 return NULL;
44468 }
44469
44470
44471 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44472 PyObject *resultobj = 0;
44473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44474 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44475 void *argp1 = 0 ;
44476 int res1 = 0 ;
44477 void *argp2 = 0 ;
44478 int res2 = 0 ;
44479 PyObject * obj0 = 0 ;
44480 PyObject * obj1 = 0 ;
44481 char * kwnames[] = {
44482 (char *) "self",(char *) "accel", NULL
44483 };
44484
44485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44487 if (!SWIG_IsOK(res1)) {
44488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44489 }
44490 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44492 if (!SWIG_IsOK(res2)) {
44493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44494 }
44495 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44496 {
44497 PyThreadState* __tstate = wxPyBeginAllowThreads();
44498 (arg1)->SetAccel(arg2);
44499 wxPyEndAllowThreads(__tstate);
44500 if (PyErr_Occurred()) SWIG_fail;
44501 }
44502 resultobj = SWIG_Py_Void();
44503 return resultobj;
44504 fail:
44505 return NULL;
44506 }
44507
44508
44509 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44510 PyObject *resultobj = 0;
44511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44512 wxBitmap *arg2 = 0 ;
44513 void *argp1 = 0 ;
44514 int res1 = 0 ;
44515 void *argp2 = 0 ;
44516 int res2 = 0 ;
44517 PyObject * obj0 = 0 ;
44518 PyObject * obj1 = 0 ;
44519 char * kwnames[] = {
44520 (char *) "self",(char *) "bitmap", NULL
44521 };
44522
44523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44525 if (!SWIG_IsOK(res1)) {
44526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44527 }
44528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44529 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44530 if (!SWIG_IsOK(res2)) {
44531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44532 }
44533 if (!argp2) {
44534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44535 }
44536 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44537 {
44538 PyThreadState* __tstate = wxPyBeginAllowThreads();
44539 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44540 wxPyEndAllowThreads(__tstate);
44541 if (PyErr_Occurred()) SWIG_fail;
44542 }
44543 resultobj = SWIG_Py_Void();
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44551 PyObject *resultobj = 0;
44552 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44553 wxBitmap *result = 0 ;
44554 void *argp1 = 0 ;
44555 int res1 = 0 ;
44556 PyObject *swig_obj[1] ;
44557
44558 if (!args) SWIG_fail;
44559 swig_obj[0] = args;
44560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44561 if (!SWIG_IsOK(res1)) {
44562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44563 }
44564 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44565 {
44566 PyThreadState* __tstate = wxPyBeginAllowThreads();
44567 {
44568 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44569 result = (wxBitmap *) &_result_ref;
44570 }
44571 wxPyEndAllowThreads(__tstate);
44572 if (PyErr_Occurred()) SWIG_fail;
44573 }
44574 {
44575 wxBitmap* resultptr = new wxBitmap(*result);
44576 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44577 }
44578 return resultobj;
44579 fail:
44580 return NULL;
44581 }
44582
44583
44584 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44585 PyObject *resultobj = 0;
44586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44587 wxFont *arg2 = 0 ;
44588 void *argp1 = 0 ;
44589 int res1 = 0 ;
44590 void *argp2 = 0 ;
44591 int res2 = 0 ;
44592 PyObject * obj0 = 0 ;
44593 PyObject * obj1 = 0 ;
44594 char * kwnames[] = {
44595 (char *) "self",(char *) "font", NULL
44596 };
44597
44598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44600 if (!SWIG_IsOK(res1)) {
44601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44602 }
44603 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44605 if (!SWIG_IsOK(res2)) {
44606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44607 }
44608 if (!argp2) {
44609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44610 }
44611 arg2 = reinterpret_cast< wxFont * >(argp2);
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44615 wxPyEndAllowThreads(__tstate);
44616 if (PyErr_Occurred()) SWIG_fail;
44617 }
44618 resultobj = SWIG_Py_Void();
44619 return resultobj;
44620 fail:
44621 return NULL;
44622 }
44623
44624
44625 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44626 PyObject *resultobj = 0;
44627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44628 wxFont result;
44629 void *argp1 = 0 ;
44630 int res1 = 0 ;
44631 PyObject *swig_obj[1] ;
44632
44633 if (!args) SWIG_fail;
44634 swig_obj[0] = args;
44635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44636 if (!SWIG_IsOK(res1)) {
44637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44638 }
44639 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44640 {
44641 PyThreadState* __tstate = wxPyBeginAllowThreads();
44642 result = wxMenuItem_GetFont(arg1);
44643 wxPyEndAllowThreads(__tstate);
44644 if (PyErr_Occurred()) SWIG_fail;
44645 }
44646 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44647 return resultobj;
44648 fail:
44649 return NULL;
44650 }
44651
44652
44653 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44654 PyObject *resultobj = 0;
44655 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44656 wxColour *arg2 = 0 ;
44657 void *argp1 = 0 ;
44658 int res1 = 0 ;
44659 wxColour temp2 ;
44660 PyObject * obj0 = 0 ;
44661 PyObject * obj1 = 0 ;
44662 char * kwnames[] = {
44663 (char *) "self",(char *) "colText", NULL
44664 };
44665
44666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44668 if (!SWIG_IsOK(res1)) {
44669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44670 }
44671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44672 {
44673 arg2 = &temp2;
44674 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44675 }
44676 {
44677 PyThreadState* __tstate = wxPyBeginAllowThreads();
44678 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44679 wxPyEndAllowThreads(__tstate);
44680 if (PyErr_Occurred()) SWIG_fail;
44681 }
44682 resultobj = SWIG_Py_Void();
44683 return resultobj;
44684 fail:
44685 return NULL;
44686 }
44687
44688
44689 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44690 PyObject *resultobj = 0;
44691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44692 wxColour result;
44693 void *argp1 = 0 ;
44694 int res1 = 0 ;
44695 PyObject *swig_obj[1] ;
44696
44697 if (!args) SWIG_fail;
44698 swig_obj[0] = args;
44699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44700 if (!SWIG_IsOK(res1)) {
44701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44702 }
44703 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44704 {
44705 PyThreadState* __tstate = wxPyBeginAllowThreads();
44706 result = wxMenuItem_GetTextColour(arg1);
44707 wxPyEndAllowThreads(__tstate);
44708 if (PyErr_Occurred()) SWIG_fail;
44709 }
44710 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44711 return resultobj;
44712 fail:
44713 return NULL;
44714 }
44715
44716
44717 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44718 PyObject *resultobj = 0;
44719 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44720 wxColour *arg2 = 0 ;
44721 void *argp1 = 0 ;
44722 int res1 = 0 ;
44723 wxColour temp2 ;
44724 PyObject * obj0 = 0 ;
44725 PyObject * obj1 = 0 ;
44726 char * kwnames[] = {
44727 (char *) "self",(char *) "colBack", NULL
44728 };
44729
44730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44732 if (!SWIG_IsOK(res1)) {
44733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44734 }
44735 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44736 {
44737 arg2 = &temp2;
44738 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44739 }
44740 {
44741 PyThreadState* __tstate = wxPyBeginAllowThreads();
44742 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44743 wxPyEndAllowThreads(__tstate);
44744 if (PyErr_Occurred()) SWIG_fail;
44745 }
44746 resultobj = SWIG_Py_Void();
44747 return resultobj;
44748 fail:
44749 return NULL;
44750 }
44751
44752
44753 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44754 PyObject *resultobj = 0;
44755 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44756 wxColour result;
44757 void *argp1 = 0 ;
44758 int res1 = 0 ;
44759 PyObject *swig_obj[1] ;
44760
44761 if (!args) SWIG_fail;
44762 swig_obj[0] = args;
44763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44764 if (!SWIG_IsOK(res1)) {
44765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44766 }
44767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44768 {
44769 PyThreadState* __tstate = wxPyBeginAllowThreads();
44770 result = wxMenuItem_GetBackgroundColour(arg1);
44771 wxPyEndAllowThreads(__tstate);
44772 if (PyErr_Occurred()) SWIG_fail;
44773 }
44774 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44775 return resultobj;
44776 fail:
44777 return NULL;
44778 }
44779
44780
44781 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44782 PyObject *resultobj = 0;
44783 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44784 wxBitmap *arg2 = 0 ;
44785 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44786 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44787 void *argp1 = 0 ;
44788 int res1 = 0 ;
44789 void *argp2 = 0 ;
44790 int res2 = 0 ;
44791 void *argp3 = 0 ;
44792 int res3 = 0 ;
44793 PyObject * obj0 = 0 ;
44794 PyObject * obj1 = 0 ;
44795 PyObject * obj2 = 0 ;
44796 char * kwnames[] = {
44797 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44798 };
44799
44800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44802 if (!SWIG_IsOK(res1)) {
44803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44804 }
44805 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44806 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44807 if (!SWIG_IsOK(res2)) {
44808 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44809 }
44810 if (!argp2) {
44811 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44812 }
44813 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44814 if (obj2) {
44815 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44816 if (!SWIG_IsOK(res3)) {
44817 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44818 }
44819 if (!argp3) {
44820 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44821 }
44822 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44823 }
44824 {
44825 PyThreadState* __tstate = wxPyBeginAllowThreads();
44826 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44827 wxPyEndAllowThreads(__tstate);
44828 if (PyErr_Occurred()) SWIG_fail;
44829 }
44830 resultobj = SWIG_Py_Void();
44831 return resultobj;
44832 fail:
44833 return NULL;
44834 }
44835
44836
44837 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44838 PyObject *resultobj = 0;
44839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44840 wxBitmap *arg2 = 0 ;
44841 void *argp1 = 0 ;
44842 int res1 = 0 ;
44843 void *argp2 = 0 ;
44844 int res2 = 0 ;
44845 PyObject * obj0 = 0 ;
44846 PyObject * obj1 = 0 ;
44847 char * kwnames[] = {
44848 (char *) "self",(char *) "bmpDisabled", NULL
44849 };
44850
44851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44853 if (!SWIG_IsOK(res1)) {
44854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44855 }
44856 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44858 if (!SWIG_IsOK(res2)) {
44859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44860 }
44861 if (!argp2) {
44862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44863 }
44864 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44865 {
44866 PyThreadState* __tstate = wxPyBeginAllowThreads();
44867 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44868 wxPyEndAllowThreads(__tstate);
44869 if (PyErr_Occurred()) SWIG_fail;
44870 }
44871 resultobj = SWIG_Py_Void();
44872 return resultobj;
44873 fail:
44874 return NULL;
44875 }
44876
44877
44878 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44879 PyObject *resultobj = 0;
44880 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44881 wxBitmap *result = 0 ;
44882 void *argp1 = 0 ;
44883 int res1 = 0 ;
44884 PyObject *swig_obj[1] ;
44885
44886 if (!args) SWIG_fail;
44887 swig_obj[0] = args;
44888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44889 if (!SWIG_IsOK(res1)) {
44890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44891 }
44892 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44893 {
44894 PyThreadState* __tstate = wxPyBeginAllowThreads();
44895 {
44896 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44897 result = (wxBitmap *) &_result_ref;
44898 }
44899 wxPyEndAllowThreads(__tstate);
44900 if (PyErr_Occurred()) SWIG_fail;
44901 }
44902 {
44903 wxBitmap* resultptr = new wxBitmap(*result);
44904 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44905 }
44906 return resultobj;
44907 fail:
44908 return NULL;
44909 }
44910
44911
44912 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44913 PyObject *resultobj = 0;
44914 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44915 int arg2 ;
44916 void *argp1 = 0 ;
44917 int res1 = 0 ;
44918 int val2 ;
44919 int ecode2 = 0 ;
44920 PyObject * obj0 = 0 ;
44921 PyObject * obj1 = 0 ;
44922 char * kwnames[] = {
44923 (char *) "self",(char *) "nWidth", NULL
44924 };
44925
44926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44928 if (!SWIG_IsOK(res1)) {
44929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44930 }
44931 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44932 ecode2 = SWIG_AsVal_int(obj1, &val2);
44933 if (!SWIG_IsOK(ecode2)) {
44934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44935 }
44936 arg2 = static_cast< int >(val2);
44937 {
44938 PyThreadState* __tstate = wxPyBeginAllowThreads();
44939 wxMenuItem_SetMarginWidth(arg1,arg2);
44940 wxPyEndAllowThreads(__tstate);
44941 if (PyErr_Occurred()) SWIG_fail;
44942 }
44943 resultobj = SWIG_Py_Void();
44944 return resultobj;
44945 fail:
44946 return NULL;
44947 }
44948
44949
44950 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44951 PyObject *resultobj = 0;
44952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44953 int result;
44954 void *argp1 = 0 ;
44955 int res1 = 0 ;
44956 PyObject *swig_obj[1] ;
44957
44958 if (!args) SWIG_fail;
44959 swig_obj[0] = args;
44960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44961 if (!SWIG_IsOK(res1)) {
44962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44963 }
44964 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44965 {
44966 PyThreadState* __tstate = wxPyBeginAllowThreads();
44967 result = (int)wxMenuItem_GetMarginWidth(arg1);
44968 wxPyEndAllowThreads(__tstate);
44969 if (PyErr_Occurred()) SWIG_fail;
44970 }
44971 resultobj = SWIG_From_int(static_cast< int >(result));
44972 return resultobj;
44973 fail:
44974 return NULL;
44975 }
44976
44977
44978 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44979 PyObject *resultobj = 0;
44980 int result;
44981
44982 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44983 {
44984 PyThreadState* __tstate = wxPyBeginAllowThreads();
44985 result = (int)wxMenuItem_GetDefaultMarginWidth();
44986 wxPyEndAllowThreads(__tstate);
44987 if (PyErr_Occurred()) SWIG_fail;
44988 }
44989 resultobj = SWIG_From_int(static_cast< int >(result));
44990 return resultobj;
44991 fail:
44992 return NULL;
44993 }
44994
44995
44996 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44997 PyObject *resultobj = 0;
44998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44999 bool result;
45000 void *argp1 = 0 ;
45001 int res1 = 0 ;
45002 PyObject *swig_obj[1] ;
45003
45004 if (!args) SWIG_fail;
45005 swig_obj[0] = args;
45006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45007 if (!SWIG_IsOK(res1)) {
45008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45009 }
45010 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45011 {
45012 PyThreadState* __tstate = wxPyBeginAllowThreads();
45013 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
45014 wxPyEndAllowThreads(__tstate);
45015 if (PyErr_Occurred()) SWIG_fail;
45016 }
45017 {
45018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45019 }
45020 return resultobj;
45021 fail:
45022 return NULL;
45023 }
45024
45025
45026 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45027 PyObject *resultobj = 0;
45028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45029 bool arg2 = (bool) true ;
45030 void *argp1 = 0 ;
45031 int res1 = 0 ;
45032 bool val2 ;
45033 int ecode2 = 0 ;
45034 PyObject * obj0 = 0 ;
45035 PyObject * obj1 = 0 ;
45036 char * kwnames[] = {
45037 (char *) "self",(char *) "ownerDrawn", NULL
45038 };
45039
45040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45042 if (!SWIG_IsOK(res1)) {
45043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45044 }
45045 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45046 if (obj1) {
45047 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45048 if (!SWIG_IsOK(ecode2)) {
45049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45050 }
45051 arg2 = static_cast< bool >(val2);
45052 }
45053 {
45054 PyThreadState* __tstate = wxPyBeginAllowThreads();
45055 wxMenuItem_SetOwnerDrawn(arg1,arg2);
45056 wxPyEndAllowThreads(__tstate);
45057 if (PyErr_Occurred()) SWIG_fail;
45058 }
45059 resultobj = SWIG_Py_Void();
45060 return resultobj;
45061 fail:
45062 return NULL;
45063 }
45064
45065
45066 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45067 PyObject *resultobj = 0;
45068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45069 void *argp1 = 0 ;
45070 int res1 = 0 ;
45071 PyObject *swig_obj[1] ;
45072
45073 if (!args) SWIG_fail;
45074 swig_obj[0] = args;
45075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45076 if (!SWIG_IsOK(res1)) {
45077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45078 }
45079 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45080 {
45081 PyThreadState* __tstate = wxPyBeginAllowThreads();
45082 wxMenuItem_ResetOwnerDrawn(arg1);
45083 wxPyEndAllowThreads(__tstate);
45084 if (PyErr_Occurred()) SWIG_fail;
45085 }
45086 resultobj = SWIG_Py_Void();
45087 return resultobj;
45088 fail:
45089 return NULL;
45090 }
45091
45092
45093 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45094 PyObject *obj;
45095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45096 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45097 return SWIG_Py_Void();
45098 }
45099
45100 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45101 return SWIG_Python_InitShadowInstance(args);
45102 }
45103
45104 SWIGINTERN int ControlNameStr_set(PyObject *) {
45105 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45106 return 1;
45107 }
45108
45109
45110 SWIGINTERN PyObject *ControlNameStr_get(void) {
45111 PyObject *pyobj = 0;
45112
45113 {
45114 #if wxUSE_UNICODE
45115 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45116 #else
45117 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45118 #endif
45119 }
45120 return pyobj;
45121 }
45122
45123
45124 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45125 PyObject *resultobj = 0;
45126 wxWindow *arg1 = (wxWindow *) 0 ;
45127 int arg2 = (int) -1 ;
45128 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45129 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45130 wxSize const &arg4_defvalue = wxDefaultSize ;
45131 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45132 long arg5 = (long) 0 ;
45133 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45134 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45135 wxString const &arg7_defvalue = wxPyControlNameStr ;
45136 wxString *arg7 = (wxString *) &arg7_defvalue ;
45137 wxControl *result = 0 ;
45138 void *argp1 = 0 ;
45139 int res1 = 0 ;
45140 int val2 ;
45141 int ecode2 = 0 ;
45142 wxPoint temp3 ;
45143 wxSize temp4 ;
45144 long val5 ;
45145 int ecode5 = 0 ;
45146 void *argp6 = 0 ;
45147 int res6 = 0 ;
45148 bool temp7 = false ;
45149 PyObject * obj0 = 0 ;
45150 PyObject * obj1 = 0 ;
45151 PyObject * obj2 = 0 ;
45152 PyObject * obj3 = 0 ;
45153 PyObject * obj4 = 0 ;
45154 PyObject * obj5 = 0 ;
45155 PyObject * obj6 = 0 ;
45156 char * kwnames[] = {
45157 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45158 };
45159
45160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45162 if (!SWIG_IsOK(res1)) {
45163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45164 }
45165 arg1 = reinterpret_cast< wxWindow * >(argp1);
45166 if (obj1) {
45167 ecode2 = SWIG_AsVal_int(obj1, &val2);
45168 if (!SWIG_IsOK(ecode2)) {
45169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45170 }
45171 arg2 = static_cast< int >(val2);
45172 }
45173 if (obj2) {
45174 {
45175 arg3 = &temp3;
45176 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45177 }
45178 }
45179 if (obj3) {
45180 {
45181 arg4 = &temp4;
45182 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45183 }
45184 }
45185 if (obj4) {
45186 ecode5 = SWIG_AsVal_long(obj4, &val5);
45187 if (!SWIG_IsOK(ecode5)) {
45188 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45189 }
45190 arg5 = static_cast< long >(val5);
45191 }
45192 if (obj5) {
45193 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45194 if (!SWIG_IsOK(res6)) {
45195 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45196 }
45197 if (!argp6) {
45198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45199 }
45200 arg6 = reinterpret_cast< wxValidator * >(argp6);
45201 }
45202 if (obj6) {
45203 {
45204 arg7 = wxString_in_helper(obj6);
45205 if (arg7 == NULL) SWIG_fail;
45206 temp7 = true;
45207 }
45208 }
45209 {
45210 if (!wxPyCheckForApp()) SWIG_fail;
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45217 {
45218 if (temp7)
45219 delete arg7;
45220 }
45221 return resultobj;
45222 fail:
45223 {
45224 if (temp7)
45225 delete arg7;
45226 }
45227 return NULL;
45228 }
45229
45230
45231 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45232 PyObject *resultobj = 0;
45233 wxControl *result = 0 ;
45234
45235 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45236 {
45237 if (!wxPyCheckForApp()) SWIG_fail;
45238 PyThreadState* __tstate = wxPyBeginAllowThreads();
45239 result = (wxControl *)new wxControl();
45240 wxPyEndAllowThreads(__tstate);
45241 if (PyErr_Occurred()) SWIG_fail;
45242 }
45243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45244 return resultobj;
45245 fail:
45246 return NULL;
45247 }
45248
45249
45250 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45251 PyObject *resultobj = 0;
45252 wxControl *arg1 = (wxControl *) 0 ;
45253 wxWindow *arg2 = (wxWindow *) 0 ;
45254 int arg3 = (int) -1 ;
45255 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45256 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45257 wxSize const &arg5_defvalue = wxDefaultSize ;
45258 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45259 long arg6 = (long) 0 ;
45260 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45261 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45262 wxString const &arg8_defvalue = wxPyControlNameStr ;
45263 wxString *arg8 = (wxString *) &arg8_defvalue ;
45264 bool result;
45265 void *argp1 = 0 ;
45266 int res1 = 0 ;
45267 void *argp2 = 0 ;
45268 int res2 = 0 ;
45269 int val3 ;
45270 int ecode3 = 0 ;
45271 wxPoint temp4 ;
45272 wxSize temp5 ;
45273 long val6 ;
45274 int ecode6 = 0 ;
45275 void *argp7 = 0 ;
45276 int res7 = 0 ;
45277 bool temp8 = false ;
45278 PyObject * obj0 = 0 ;
45279 PyObject * obj1 = 0 ;
45280 PyObject * obj2 = 0 ;
45281 PyObject * obj3 = 0 ;
45282 PyObject * obj4 = 0 ;
45283 PyObject * obj5 = 0 ;
45284 PyObject * obj6 = 0 ;
45285 PyObject * obj7 = 0 ;
45286 char * kwnames[] = {
45287 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45288 };
45289
45290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45292 if (!SWIG_IsOK(res1)) {
45293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45294 }
45295 arg1 = reinterpret_cast< wxControl * >(argp1);
45296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45297 if (!SWIG_IsOK(res2)) {
45298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45299 }
45300 arg2 = reinterpret_cast< wxWindow * >(argp2);
45301 if (obj2) {
45302 ecode3 = SWIG_AsVal_int(obj2, &val3);
45303 if (!SWIG_IsOK(ecode3)) {
45304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45305 }
45306 arg3 = static_cast< int >(val3);
45307 }
45308 if (obj3) {
45309 {
45310 arg4 = &temp4;
45311 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45312 }
45313 }
45314 if (obj4) {
45315 {
45316 arg5 = &temp5;
45317 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45318 }
45319 }
45320 if (obj5) {
45321 ecode6 = SWIG_AsVal_long(obj5, &val6);
45322 if (!SWIG_IsOK(ecode6)) {
45323 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45324 }
45325 arg6 = static_cast< long >(val6);
45326 }
45327 if (obj6) {
45328 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45329 if (!SWIG_IsOK(res7)) {
45330 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45331 }
45332 if (!argp7) {
45333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45334 }
45335 arg7 = reinterpret_cast< wxValidator * >(argp7);
45336 }
45337 if (obj7) {
45338 {
45339 arg8 = wxString_in_helper(obj7);
45340 if (arg8 == NULL) SWIG_fail;
45341 temp8 = true;
45342 }
45343 }
45344 {
45345 PyThreadState* __tstate = wxPyBeginAllowThreads();
45346 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45347 wxPyEndAllowThreads(__tstate);
45348 if (PyErr_Occurred()) SWIG_fail;
45349 }
45350 {
45351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45352 }
45353 {
45354 if (temp8)
45355 delete arg8;
45356 }
45357 return resultobj;
45358 fail:
45359 {
45360 if (temp8)
45361 delete arg8;
45362 }
45363 return NULL;
45364 }
45365
45366
45367 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45368 PyObject *resultobj = 0;
45369 wxControl *arg1 = (wxControl *) 0 ;
45370 int result;
45371 void *argp1 = 0 ;
45372 int res1 = 0 ;
45373 PyObject *swig_obj[1] ;
45374
45375 if (!args) SWIG_fail;
45376 swig_obj[0] = args;
45377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45378 if (!SWIG_IsOK(res1)) {
45379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45380 }
45381 arg1 = reinterpret_cast< wxControl * >(argp1);
45382 {
45383 PyThreadState* __tstate = wxPyBeginAllowThreads();
45384 result = (int)((wxControl const *)arg1)->GetAlignment();
45385 wxPyEndAllowThreads(__tstate);
45386 if (PyErr_Occurred()) SWIG_fail;
45387 }
45388 resultobj = SWIG_From_int(static_cast< int >(result));
45389 return resultobj;
45390 fail:
45391 return NULL;
45392 }
45393
45394
45395 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45396 PyObject *resultobj = 0;
45397 wxControl *arg1 = (wxControl *) 0 ;
45398 wxString result;
45399 void *argp1 = 0 ;
45400 int res1 = 0 ;
45401 PyObject *swig_obj[1] ;
45402
45403 if (!args) SWIG_fail;
45404 swig_obj[0] = args;
45405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45406 if (!SWIG_IsOK(res1)) {
45407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45408 }
45409 arg1 = reinterpret_cast< wxControl * >(argp1);
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 result = ((wxControl const *)arg1)->GetLabelText();
45413 wxPyEndAllowThreads(__tstate);
45414 if (PyErr_Occurred()) SWIG_fail;
45415 }
45416 {
45417 #if wxUSE_UNICODE
45418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45419 #else
45420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45421 #endif
45422 }
45423 return resultobj;
45424 fail:
45425 return NULL;
45426 }
45427
45428
45429 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45430 PyObject *resultobj = 0;
45431 wxControl *arg1 = (wxControl *) 0 ;
45432 wxCommandEvent *arg2 = 0 ;
45433 void *argp1 = 0 ;
45434 int res1 = 0 ;
45435 void *argp2 = 0 ;
45436 int res2 = 0 ;
45437 PyObject * obj0 = 0 ;
45438 PyObject * obj1 = 0 ;
45439 char * kwnames[] = {
45440 (char *) "self",(char *) "event", NULL
45441 };
45442
45443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45445 if (!SWIG_IsOK(res1)) {
45446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45447 }
45448 arg1 = reinterpret_cast< wxControl * >(argp1);
45449 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45450 if (!SWIG_IsOK(res2)) {
45451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45452 }
45453 if (!argp2) {
45454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45455 }
45456 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45457 {
45458 PyThreadState* __tstate = wxPyBeginAllowThreads();
45459 (arg1)->Command(*arg2);
45460 wxPyEndAllowThreads(__tstate);
45461 if (PyErr_Occurred()) SWIG_fail;
45462 }
45463 resultobj = SWIG_Py_Void();
45464 return resultobj;
45465 fail:
45466 return NULL;
45467 }
45468
45469
45470 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45471 PyObject *resultobj = 0;
45472 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45473 SwigValueWrapper<wxVisualAttributes > result;
45474 int val1 ;
45475 int ecode1 = 0 ;
45476 PyObject * obj0 = 0 ;
45477 char * kwnames[] = {
45478 (char *) "variant", NULL
45479 };
45480
45481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45482 if (obj0) {
45483 ecode1 = SWIG_AsVal_int(obj0, &val1);
45484 if (!SWIG_IsOK(ecode1)) {
45485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45486 }
45487 arg1 = static_cast< wxWindowVariant >(val1);
45488 }
45489 {
45490 if (!wxPyCheckForApp()) SWIG_fail;
45491 PyThreadState* __tstate = wxPyBeginAllowThreads();
45492 result = wxControl::GetClassDefaultAttributes(arg1);
45493 wxPyEndAllowThreads(__tstate);
45494 if (PyErr_Occurred()) SWIG_fail;
45495 }
45496 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45497 return resultobj;
45498 fail:
45499 return NULL;
45500 }
45501
45502
45503 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45504 PyObject *obj;
45505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45506 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45507 return SWIG_Py_Void();
45508 }
45509
45510 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45511 return SWIG_Python_InitShadowInstance(args);
45512 }
45513
45514 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45515 PyObject *resultobj = 0;
45516 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45517 wxString *arg2 = 0 ;
45518 PyObject *arg3 = (PyObject *) NULL ;
45519 int result;
45520 void *argp1 = 0 ;
45521 int res1 = 0 ;
45522 bool temp2 = false ;
45523 PyObject * obj0 = 0 ;
45524 PyObject * obj1 = 0 ;
45525 PyObject * obj2 = 0 ;
45526 char * kwnames[] = {
45527 (char *) "self",(char *) "item",(char *) "clientData", NULL
45528 };
45529
45530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45532 if (!SWIG_IsOK(res1)) {
45533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45534 }
45535 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45536 {
45537 arg2 = wxString_in_helper(obj1);
45538 if (arg2 == NULL) SWIG_fail;
45539 temp2 = true;
45540 }
45541 if (obj2) {
45542 arg3 = obj2;
45543 }
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45547 wxPyEndAllowThreads(__tstate);
45548 if (PyErr_Occurred()) SWIG_fail;
45549 }
45550 resultobj = SWIG_From_int(static_cast< int >(result));
45551 {
45552 if (temp2)
45553 delete arg2;
45554 }
45555 return resultobj;
45556 fail:
45557 {
45558 if (temp2)
45559 delete arg2;
45560 }
45561 return NULL;
45562 }
45563
45564
45565 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45566 PyObject *resultobj = 0;
45567 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45568 wxArrayString *arg2 = 0 ;
45569 void *argp1 = 0 ;
45570 int res1 = 0 ;
45571 bool temp2 = false ;
45572 PyObject * obj0 = 0 ;
45573 PyObject * obj1 = 0 ;
45574 char * kwnames[] = {
45575 (char *) "self",(char *) "strings", NULL
45576 };
45577
45578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45580 if (!SWIG_IsOK(res1)) {
45581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45582 }
45583 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45584 {
45585 if (! PySequence_Check(obj1)) {
45586 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45587 SWIG_fail;
45588 }
45589 arg2 = new wxArrayString;
45590 temp2 = true;
45591 int i, len=PySequence_Length(obj1);
45592 for (i=0; i<len; i++) {
45593 PyObject* item = PySequence_GetItem(obj1, i);
45594 wxString* s = wxString_in_helper(item);
45595 if (PyErr_Occurred()) SWIG_fail;
45596 arg2->Add(*s);
45597 delete s;
45598 Py_DECREF(item);
45599 }
45600 }
45601 {
45602 PyThreadState* __tstate = wxPyBeginAllowThreads();
45603 (arg1)->Append((wxArrayString const &)*arg2);
45604 wxPyEndAllowThreads(__tstate);
45605 if (PyErr_Occurred()) SWIG_fail;
45606 }
45607 resultobj = SWIG_Py_Void();
45608 {
45609 if (temp2) delete arg2;
45610 }
45611 return resultobj;
45612 fail:
45613 {
45614 if (temp2) delete arg2;
45615 }
45616 return NULL;
45617 }
45618
45619
45620 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45621 PyObject *resultobj = 0;
45622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45623 wxString *arg2 = 0 ;
45624 unsigned int arg3 ;
45625 PyObject *arg4 = (PyObject *) NULL ;
45626 int result;
45627 void *argp1 = 0 ;
45628 int res1 = 0 ;
45629 bool temp2 = false ;
45630 unsigned int val3 ;
45631 int ecode3 = 0 ;
45632 PyObject * obj0 = 0 ;
45633 PyObject * obj1 = 0 ;
45634 PyObject * obj2 = 0 ;
45635 PyObject * obj3 = 0 ;
45636 char * kwnames[] = {
45637 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45638 };
45639
45640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45642 if (!SWIG_IsOK(res1)) {
45643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45644 }
45645 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45646 {
45647 arg2 = wxString_in_helper(obj1);
45648 if (arg2 == NULL) SWIG_fail;
45649 temp2 = true;
45650 }
45651 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45652 if (!SWIG_IsOK(ecode3)) {
45653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45654 }
45655 arg3 = static_cast< unsigned int >(val3);
45656 if (obj3) {
45657 arg4 = obj3;
45658 }
45659 {
45660 PyThreadState* __tstate = wxPyBeginAllowThreads();
45661 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45662 wxPyEndAllowThreads(__tstate);
45663 if (PyErr_Occurred()) SWIG_fail;
45664 }
45665 resultobj = SWIG_From_int(static_cast< int >(result));
45666 {
45667 if (temp2)
45668 delete arg2;
45669 }
45670 return resultobj;
45671 fail:
45672 {
45673 if (temp2)
45674 delete arg2;
45675 }
45676 return NULL;
45677 }
45678
45679
45680 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45681 PyObject *resultobj = 0;
45682 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45683 void *argp1 = 0 ;
45684 int res1 = 0 ;
45685 PyObject *swig_obj[1] ;
45686
45687 if (!args) SWIG_fail;
45688 swig_obj[0] = args;
45689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45690 if (!SWIG_IsOK(res1)) {
45691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45692 }
45693 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45694 {
45695 PyThreadState* __tstate = wxPyBeginAllowThreads();
45696 (arg1)->Clear();
45697 wxPyEndAllowThreads(__tstate);
45698 if (PyErr_Occurred()) SWIG_fail;
45699 }
45700 resultobj = SWIG_Py_Void();
45701 return resultobj;
45702 fail:
45703 return NULL;
45704 }
45705
45706
45707 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45708 PyObject *resultobj = 0;
45709 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45710 unsigned int arg2 ;
45711 void *argp1 = 0 ;
45712 int res1 = 0 ;
45713 unsigned int val2 ;
45714 int ecode2 = 0 ;
45715 PyObject * obj0 = 0 ;
45716 PyObject * obj1 = 0 ;
45717 char * kwnames[] = {
45718 (char *) "self",(char *) "n", NULL
45719 };
45720
45721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45723 if (!SWIG_IsOK(res1)) {
45724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45725 }
45726 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45727 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45728 if (!SWIG_IsOK(ecode2)) {
45729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45730 }
45731 arg2 = static_cast< unsigned int >(val2);
45732 {
45733 PyThreadState* __tstate = wxPyBeginAllowThreads();
45734 (arg1)->Delete(arg2);
45735 wxPyEndAllowThreads(__tstate);
45736 if (PyErr_Occurred()) SWIG_fail;
45737 }
45738 resultobj = SWIG_Py_Void();
45739 return resultobj;
45740 fail:
45741 return NULL;
45742 }
45743
45744
45745 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45746 PyObject *resultobj = 0;
45747 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45748 unsigned int arg2 ;
45749 PyObject *result = 0 ;
45750 void *argp1 = 0 ;
45751 int res1 = 0 ;
45752 unsigned int val2 ;
45753 int ecode2 = 0 ;
45754 PyObject * obj0 = 0 ;
45755 PyObject * obj1 = 0 ;
45756 char * kwnames[] = {
45757 (char *) "self",(char *) "n", NULL
45758 };
45759
45760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45762 if (!SWIG_IsOK(res1)) {
45763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45764 }
45765 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45766 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45767 if (!SWIG_IsOK(ecode2)) {
45768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45769 }
45770 arg2 = static_cast< unsigned int >(val2);
45771 {
45772 PyThreadState* __tstate = wxPyBeginAllowThreads();
45773 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45774 wxPyEndAllowThreads(__tstate);
45775 if (PyErr_Occurred()) SWIG_fail;
45776 }
45777 resultobj = result;
45778 return resultobj;
45779 fail:
45780 return NULL;
45781 }
45782
45783
45784 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45785 PyObject *resultobj = 0;
45786 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45787 unsigned int arg2 ;
45788 PyObject *arg3 = (PyObject *) 0 ;
45789 void *argp1 = 0 ;
45790 int res1 = 0 ;
45791 unsigned int val2 ;
45792 int ecode2 = 0 ;
45793 PyObject * obj0 = 0 ;
45794 PyObject * obj1 = 0 ;
45795 PyObject * obj2 = 0 ;
45796 char * kwnames[] = {
45797 (char *) "self",(char *) "n",(char *) "clientData", NULL
45798 };
45799
45800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45802 if (!SWIG_IsOK(res1)) {
45803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45804 }
45805 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45806 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45807 if (!SWIG_IsOK(ecode2)) {
45808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45809 }
45810 arg2 = static_cast< unsigned int >(val2);
45811 arg3 = obj2;
45812 {
45813 PyThreadState* __tstate = wxPyBeginAllowThreads();
45814 wxItemContainer_SetClientData(arg1,arg2,arg3);
45815 wxPyEndAllowThreads(__tstate);
45816 if (PyErr_Occurred()) SWIG_fail;
45817 }
45818 resultobj = SWIG_Py_Void();
45819 return resultobj;
45820 fail:
45821 return NULL;
45822 }
45823
45824
45825 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45826 PyObject *resultobj = 0;
45827 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45828 unsigned int result;
45829 void *argp1 = 0 ;
45830 int res1 = 0 ;
45831 PyObject *swig_obj[1] ;
45832
45833 if (!args) SWIG_fail;
45834 swig_obj[0] = args;
45835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45836 if (!SWIG_IsOK(res1)) {
45837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45838 }
45839 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45840 {
45841 PyThreadState* __tstate = wxPyBeginAllowThreads();
45842 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45843 wxPyEndAllowThreads(__tstate);
45844 if (PyErr_Occurred()) SWIG_fail;
45845 }
45846 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45847 return resultobj;
45848 fail:
45849 return NULL;
45850 }
45851
45852
45853 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45854 PyObject *resultobj = 0;
45855 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45856 bool 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_wxItemContainer, 0 | 0 );
45864 if (!SWIG_IsOK(res1)) {
45865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45866 }
45867 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45868 {
45869 PyThreadState* __tstate = wxPyBeginAllowThreads();
45870 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 {
45875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45876 }
45877 return resultobj;
45878 fail:
45879 return NULL;
45880 }
45881
45882
45883 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45884 PyObject *resultobj = 0;
45885 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45886 unsigned int arg2 ;
45887 wxString result;
45888 void *argp1 = 0 ;
45889 int res1 = 0 ;
45890 unsigned int val2 ;
45891 int ecode2 = 0 ;
45892 PyObject * obj0 = 0 ;
45893 PyObject * obj1 = 0 ;
45894 char * kwnames[] = {
45895 (char *) "self",(char *) "n", NULL
45896 };
45897
45898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45900 if (!SWIG_IsOK(res1)) {
45901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45902 }
45903 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45904 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45905 if (!SWIG_IsOK(ecode2)) {
45906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45907 }
45908 arg2 = static_cast< unsigned int >(val2);
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45912 wxPyEndAllowThreads(__tstate);
45913 if (PyErr_Occurred()) SWIG_fail;
45914 }
45915 {
45916 #if wxUSE_UNICODE
45917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45918 #else
45919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45920 #endif
45921 }
45922 return resultobj;
45923 fail:
45924 return NULL;
45925 }
45926
45927
45928 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45929 PyObject *resultobj = 0;
45930 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45931 wxArrayString result;
45932 void *argp1 = 0 ;
45933 int res1 = 0 ;
45934 PyObject *swig_obj[1] ;
45935
45936 if (!args) SWIG_fail;
45937 swig_obj[0] = args;
45938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45939 if (!SWIG_IsOK(res1)) {
45940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45941 }
45942 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45943 {
45944 PyThreadState* __tstate = wxPyBeginAllowThreads();
45945 result = ((wxItemContainer const *)arg1)->GetStrings();
45946 wxPyEndAllowThreads(__tstate);
45947 if (PyErr_Occurred()) SWIG_fail;
45948 }
45949 {
45950 resultobj = wxArrayString2PyList_helper(result);
45951 }
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45959 PyObject *resultobj = 0;
45960 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45961 unsigned int arg2 ;
45962 wxString *arg3 = 0 ;
45963 void *argp1 = 0 ;
45964 int res1 = 0 ;
45965 unsigned int val2 ;
45966 int ecode2 = 0 ;
45967 bool temp3 = false ;
45968 PyObject * obj0 = 0 ;
45969 PyObject * obj1 = 0 ;
45970 PyObject * obj2 = 0 ;
45971 char * kwnames[] = {
45972 (char *) "self",(char *) "n",(char *) "s", NULL
45973 };
45974
45975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45977 if (!SWIG_IsOK(res1)) {
45978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45979 }
45980 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45981 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45982 if (!SWIG_IsOK(ecode2)) {
45983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45984 }
45985 arg2 = static_cast< unsigned int >(val2);
45986 {
45987 arg3 = wxString_in_helper(obj2);
45988 if (arg3 == NULL) SWIG_fail;
45989 temp3 = true;
45990 }
45991 {
45992 PyThreadState* __tstate = wxPyBeginAllowThreads();
45993 (arg1)->SetString(arg2,(wxString const &)*arg3);
45994 wxPyEndAllowThreads(__tstate);
45995 if (PyErr_Occurred()) SWIG_fail;
45996 }
45997 resultobj = SWIG_Py_Void();
45998 {
45999 if (temp3)
46000 delete arg3;
46001 }
46002 return resultobj;
46003 fail:
46004 {
46005 if (temp3)
46006 delete arg3;
46007 }
46008 return NULL;
46009 }
46010
46011
46012 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46013 PyObject *resultobj = 0;
46014 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46015 wxString *arg2 = 0 ;
46016 int result;
46017 void *argp1 = 0 ;
46018 int res1 = 0 ;
46019 bool temp2 = false ;
46020 PyObject * obj0 = 0 ;
46021 PyObject * obj1 = 0 ;
46022 char * kwnames[] = {
46023 (char *) "self",(char *) "s", NULL
46024 };
46025
46026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46028 if (!SWIG_IsOK(res1)) {
46029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46030 }
46031 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46032 {
46033 arg2 = wxString_in_helper(obj1);
46034 if (arg2 == NULL) SWIG_fail;
46035 temp2 = true;
46036 }
46037 {
46038 PyThreadState* __tstate = wxPyBeginAllowThreads();
46039 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46040 wxPyEndAllowThreads(__tstate);
46041 if (PyErr_Occurred()) SWIG_fail;
46042 }
46043 resultobj = SWIG_From_int(static_cast< int >(result));
46044 {
46045 if (temp2)
46046 delete arg2;
46047 }
46048 return resultobj;
46049 fail:
46050 {
46051 if (temp2)
46052 delete arg2;
46053 }
46054 return NULL;
46055 }
46056
46057
46058 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46059 PyObject *resultobj = 0;
46060 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46061 int arg2 ;
46062 void *argp1 = 0 ;
46063 int res1 = 0 ;
46064 int val2 ;
46065 int ecode2 = 0 ;
46066 PyObject * obj0 = 0 ;
46067 PyObject * obj1 = 0 ;
46068 char * kwnames[] = {
46069 (char *) "self",(char *) "n", NULL
46070 };
46071
46072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46074 if (!SWIG_IsOK(res1)) {
46075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46076 }
46077 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46078 ecode2 = SWIG_AsVal_int(obj1, &val2);
46079 if (!SWIG_IsOK(ecode2)) {
46080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46081 }
46082 arg2 = static_cast< int >(val2);
46083 {
46084 PyThreadState* __tstate = wxPyBeginAllowThreads();
46085 (arg1)->SetSelection(arg2);
46086 wxPyEndAllowThreads(__tstate);
46087 if (PyErr_Occurred()) SWIG_fail;
46088 }
46089 resultobj = SWIG_Py_Void();
46090 return resultobj;
46091 fail:
46092 return NULL;
46093 }
46094
46095
46096 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46097 PyObject *resultobj = 0;
46098 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46099 int result;
46100 void *argp1 = 0 ;
46101 int res1 = 0 ;
46102 PyObject *swig_obj[1] ;
46103
46104 if (!args) SWIG_fail;
46105 swig_obj[0] = args;
46106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46107 if (!SWIG_IsOK(res1)) {
46108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46109 }
46110 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46111 {
46112 PyThreadState* __tstate = wxPyBeginAllowThreads();
46113 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46114 wxPyEndAllowThreads(__tstate);
46115 if (PyErr_Occurred()) SWIG_fail;
46116 }
46117 resultobj = SWIG_From_int(static_cast< int >(result));
46118 return resultobj;
46119 fail:
46120 return NULL;
46121 }
46122
46123
46124 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46125 PyObject *resultobj = 0;
46126 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46127 wxString *arg2 = 0 ;
46128 bool result;
46129 void *argp1 = 0 ;
46130 int res1 = 0 ;
46131 bool temp2 = false ;
46132 PyObject * obj0 = 0 ;
46133 PyObject * obj1 = 0 ;
46134 char * kwnames[] = {
46135 (char *) "self",(char *) "s", NULL
46136 };
46137
46138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46140 if (!SWIG_IsOK(res1)) {
46141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46142 }
46143 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46144 {
46145 arg2 = wxString_in_helper(obj1);
46146 if (arg2 == NULL) SWIG_fail;
46147 temp2 = true;
46148 }
46149 {
46150 PyThreadState* __tstate = wxPyBeginAllowThreads();
46151 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46152 wxPyEndAllowThreads(__tstate);
46153 if (PyErr_Occurred()) SWIG_fail;
46154 }
46155 {
46156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46157 }
46158 {
46159 if (temp2)
46160 delete arg2;
46161 }
46162 return resultobj;
46163 fail:
46164 {
46165 if (temp2)
46166 delete arg2;
46167 }
46168 return NULL;
46169 }
46170
46171
46172 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46173 PyObject *resultobj = 0;
46174 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46175 wxString result;
46176 void *argp1 = 0 ;
46177 int res1 = 0 ;
46178 PyObject *swig_obj[1] ;
46179
46180 if (!args) SWIG_fail;
46181 swig_obj[0] = args;
46182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46183 if (!SWIG_IsOK(res1)) {
46184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46185 }
46186 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46187 {
46188 PyThreadState* __tstate = wxPyBeginAllowThreads();
46189 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46190 wxPyEndAllowThreads(__tstate);
46191 if (PyErr_Occurred()) SWIG_fail;
46192 }
46193 {
46194 #if wxUSE_UNICODE
46195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46196 #else
46197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46198 #endif
46199 }
46200 return resultobj;
46201 fail:
46202 return NULL;
46203 }
46204
46205
46206 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46207 PyObject *resultobj = 0;
46208 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46209 int arg2 ;
46210 void *argp1 = 0 ;
46211 int res1 = 0 ;
46212 int val2 ;
46213 int ecode2 = 0 ;
46214 PyObject * obj0 = 0 ;
46215 PyObject * obj1 = 0 ;
46216 char * kwnames[] = {
46217 (char *) "self",(char *) "n", NULL
46218 };
46219
46220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46222 if (!SWIG_IsOK(res1)) {
46223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46224 }
46225 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46226 ecode2 = SWIG_AsVal_int(obj1, &val2);
46227 if (!SWIG_IsOK(ecode2)) {
46228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46229 }
46230 arg2 = static_cast< int >(val2);
46231 {
46232 PyThreadState* __tstate = wxPyBeginAllowThreads();
46233 (arg1)->Select(arg2);
46234 wxPyEndAllowThreads(__tstate);
46235 if (PyErr_Occurred()) SWIG_fail;
46236 }
46237 resultobj = SWIG_Py_Void();
46238 return resultobj;
46239 fail:
46240 return NULL;
46241 }
46242
46243
46244 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46245 PyObject *obj;
46246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46247 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46248 return SWIG_Py_Void();
46249 }
46250
46251 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46252 PyObject *obj;
46253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46254 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46255 return SWIG_Py_Void();
46256 }
46257
46258 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46259 PyObject *resultobj = 0;
46260 wxSizerItem *result = 0 ;
46261
46262 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46263 {
46264 PyThreadState* __tstate = wxPyBeginAllowThreads();
46265 result = (wxSizerItem *)new wxSizerItem();
46266 wxPyEndAllowThreads(__tstate);
46267 if (PyErr_Occurred()) SWIG_fail;
46268 }
46269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46270 return resultobj;
46271 fail:
46272 return NULL;
46273 }
46274
46275
46276 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46277 PyObject *resultobj = 0;
46278 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46279 void *argp1 = 0 ;
46280 int res1 = 0 ;
46281 PyObject *swig_obj[1] ;
46282
46283 if (!args) SWIG_fail;
46284 swig_obj[0] = args;
46285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46286 if (!SWIG_IsOK(res1)) {
46287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46288 }
46289 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46290 {
46291 PyThreadState* __tstate = wxPyBeginAllowThreads();
46292 delete arg1;
46293
46294 wxPyEndAllowThreads(__tstate);
46295 if (PyErr_Occurred()) SWIG_fail;
46296 }
46297 resultobj = SWIG_Py_Void();
46298 return resultobj;
46299 fail:
46300 return NULL;
46301 }
46302
46303
46304 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46305 PyObject *resultobj = 0;
46306 wxWindow *arg1 = (wxWindow *) 0 ;
46307 int arg2 ;
46308 int arg3 ;
46309 int arg4 ;
46310 PyObject *arg5 = (PyObject *) NULL ;
46311 wxSizerItem *result = 0 ;
46312 void *argp1 = 0 ;
46313 int res1 = 0 ;
46314 int val2 ;
46315 int ecode2 = 0 ;
46316 int val3 ;
46317 int ecode3 = 0 ;
46318 int val4 ;
46319 int ecode4 = 0 ;
46320 PyObject * obj0 = 0 ;
46321 PyObject * obj1 = 0 ;
46322 PyObject * obj2 = 0 ;
46323 PyObject * obj3 = 0 ;
46324 PyObject * obj4 = 0 ;
46325 char * kwnames[] = {
46326 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46327 };
46328
46329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46331 if (!SWIG_IsOK(res1)) {
46332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46333 }
46334 arg1 = reinterpret_cast< wxWindow * >(argp1);
46335 ecode2 = SWIG_AsVal_int(obj1, &val2);
46336 if (!SWIG_IsOK(ecode2)) {
46337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46338 }
46339 arg2 = static_cast< int >(val2);
46340 ecode3 = SWIG_AsVal_int(obj2, &val3);
46341 if (!SWIG_IsOK(ecode3)) {
46342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46343 }
46344 arg3 = static_cast< int >(val3);
46345 ecode4 = SWIG_AsVal_int(obj3, &val4);
46346 if (!SWIG_IsOK(ecode4)) {
46347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46348 }
46349 arg4 = static_cast< int >(val4);
46350 if (obj4) {
46351 arg5 = obj4;
46352 }
46353 {
46354 PyThreadState* __tstate = wxPyBeginAllowThreads();
46355 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46356 wxPyEndAllowThreads(__tstate);
46357 if (PyErr_Occurred()) SWIG_fail;
46358 }
46359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46360 return resultobj;
46361 fail:
46362 return NULL;
46363 }
46364
46365
46366 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46367 PyObject *resultobj = 0;
46368 int arg1 ;
46369 int arg2 ;
46370 int arg3 ;
46371 int arg4 ;
46372 int arg5 ;
46373 PyObject *arg6 = (PyObject *) NULL ;
46374 wxSizerItem *result = 0 ;
46375 int val1 ;
46376 int ecode1 = 0 ;
46377 int val2 ;
46378 int ecode2 = 0 ;
46379 int val3 ;
46380 int ecode3 = 0 ;
46381 int val4 ;
46382 int ecode4 = 0 ;
46383 int val5 ;
46384 int ecode5 = 0 ;
46385 PyObject * obj0 = 0 ;
46386 PyObject * obj1 = 0 ;
46387 PyObject * obj2 = 0 ;
46388 PyObject * obj3 = 0 ;
46389 PyObject * obj4 = 0 ;
46390 PyObject * obj5 = 0 ;
46391 char * kwnames[] = {
46392 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46393 };
46394
46395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46396 ecode1 = SWIG_AsVal_int(obj0, &val1);
46397 if (!SWIG_IsOK(ecode1)) {
46398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46399 }
46400 arg1 = static_cast< int >(val1);
46401 ecode2 = SWIG_AsVal_int(obj1, &val2);
46402 if (!SWIG_IsOK(ecode2)) {
46403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46404 }
46405 arg2 = static_cast< int >(val2);
46406 ecode3 = SWIG_AsVal_int(obj2, &val3);
46407 if (!SWIG_IsOK(ecode3)) {
46408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46409 }
46410 arg3 = static_cast< int >(val3);
46411 ecode4 = SWIG_AsVal_int(obj3, &val4);
46412 if (!SWIG_IsOK(ecode4)) {
46413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46414 }
46415 arg4 = static_cast< int >(val4);
46416 ecode5 = SWIG_AsVal_int(obj4, &val5);
46417 if (!SWIG_IsOK(ecode5)) {
46418 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46419 }
46420 arg5 = static_cast< int >(val5);
46421 if (obj5) {
46422 arg6 = obj5;
46423 }
46424 {
46425 PyThreadState* __tstate = wxPyBeginAllowThreads();
46426 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46427 wxPyEndAllowThreads(__tstate);
46428 if (PyErr_Occurred()) SWIG_fail;
46429 }
46430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46431 return resultobj;
46432 fail:
46433 return NULL;
46434 }
46435
46436
46437 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46438 PyObject *resultobj = 0;
46439 wxSizer *arg1 = (wxSizer *) 0 ;
46440 int arg2 ;
46441 int arg3 ;
46442 int arg4 ;
46443 PyObject *arg5 = (PyObject *) NULL ;
46444 wxSizerItem *result = 0 ;
46445 int res1 = 0 ;
46446 int val2 ;
46447 int ecode2 = 0 ;
46448 int val3 ;
46449 int ecode3 = 0 ;
46450 int val4 ;
46451 int ecode4 = 0 ;
46452 PyObject * obj0 = 0 ;
46453 PyObject * obj1 = 0 ;
46454 PyObject * obj2 = 0 ;
46455 PyObject * obj3 = 0 ;
46456 PyObject * obj4 = 0 ;
46457 char * kwnames[] = {
46458 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46459 };
46460
46461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46462 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46463 if (!SWIG_IsOK(res1)) {
46464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46465 }
46466 ecode2 = SWIG_AsVal_int(obj1, &val2);
46467 if (!SWIG_IsOK(ecode2)) {
46468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46469 }
46470 arg2 = static_cast< int >(val2);
46471 ecode3 = SWIG_AsVal_int(obj2, &val3);
46472 if (!SWIG_IsOK(ecode3)) {
46473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46474 }
46475 arg3 = static_cast< int >(val3);
46476 ecode4 = SWIG_AsVal_int(obj3, &val4);
46477 if (!SWIG_IsOK(ecode4)) {
46478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46479 }
46480 arg4 = static_cast< int >(val4);
46481 if (obj4) {
46482 arg5 = obj4;
46483 }
46484 {
46485 PyThreadState* __tstate = wxPyBeginAllowThreads();
46486 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46487 wxPyEndAllowThreads(__tstate);
46488 if (PyErr_Occurred()) SWIG_fail;
46489 }
46490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46491 return resultobj;
46492 fail:
46493 return NULL;
46494 }
46495
46496
46497 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46498 PyObject *resultobj = 0;
46499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46500 void *argp1 = 0 ;
46501 int res1 = 0 ;
46502 PyObject *swig_obj[1] ;
46503
46504 if (!args) SWIG_fail;
46505 swig_obj[0] = args;
46506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46507 if (!SWIG_IsOK(res1)) {
46508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46509 }
46510 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46511 {
46512 PyThreadState* __tstate = wxPyBeginAllowThreads();
46513 (arg1)->DeleteWindows();
46514 wxPyEndAllowThreads(__tstate);
46515 if (PyErr_Occurred()) SWIG_fail;
46516 }
46517 resultobj = SWIG_Py_Void();
46518 return resultobj;
46519 fail:
46520 return NULL;
46521 }
46522
46523
46524 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46525 PyObject *resultobj = 0;
46526 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46527 void *argp1 = 0 ;
46528 int res1 = 0 ;
46529 PyObject *swig_obj[1] ;
46530
46531 if (!args) SWIG_fail;
46532 swig_obj[0] = args;
46533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46534 if (!SWIG_IsOK(res1)) {
46535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46536 }
46537 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46538 {
46539 PyThreadState* __tstate = wxPyBeginAllowThreads();
46540 (arg1)->DetachSizer();
46541 wxPyEndAllowThreads(__tstate);
46542 if (PyErr_Occurred()) SWIG_fail;
46543 }
46544 resultobj = SWIG_Py_Void();
46545 return resultobj;
46546 fail:
46547 return NULL;
46548 }
46549
46550
46551 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46552 PyObject *resultobj = 0;
46553 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46554 wxSize result;
46555 void *argp1 = 0 ;
46556 int res1 = 0 ;
46557 PyObject *swig_obj[1] ;
46558
46559 if (!args) SWIG_fail;
46560 swig_obj[0] = args;
46561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46562 if (!SWIG_IsOK(res1)) {
46563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46564 }
46565 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46566 {
46567 PyThreadState* __tstate = wxPyBeginAllowThreads();
46568 result = (arg1)->GetSize();
46569 wxPyEndAllowThreads(__tstate);
46570 if (PyErr_Occurred()) SWIG_fail;
46571 }
46572 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46573 return resultobj;
46574 fail:
46575 return NULL;
46576 }
46577
46578
46579 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46580 PyObject *resultobj = 0;
46581 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46582 wxSize result;
46583 void *argp1 = 0 ;
46584 int res1 = 0 ;
46585 PyObject *swig_obj[1] ;
46586
46587 if (!args) SWIG_fail;
46588 swig_obj[0] = args;
46589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46590 if (!SWIG_IsOK(res1)) {
46591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46592 }
46593 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46594 {
46595 PyThreadState* __tstate = wxPyBeginAllowThreads();
46596 result = (arg1)->CalcMin();
46597 wxPyEndAllowThreads(__tstate);
46598 if (PyErr_Occurred()) SWIG_fail;
46599 }
46600 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46601 return resultobj;
46602 fail:
46603 return NULL;
46604 }
46605
46606
46607 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46608 PyObject *resultobj = 0;
46609 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46610 wxPoint *arg2 = 0 ;
46611 wxSize *arg3 = 0 ;
46612 void *argp1 = 0 ;
46613 int res1 = 0 ;
46614 wxPoint temp2 ;
46615 wxSize temp3 ;
46616 PyObject * obj0 = 0 ;
46617 PyObject * obj1 = 0 ;
46618 PyObject * obj2 = 0 ;
46619 char * kwnames[] = {
46620 (char *) "self",(char *) "pos",(char *) "size", NULL
46621 };
46622
46623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46625 if (!SWIG_IsOK(res1)) {
46626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46627 }
46628 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46629 {
46630 arg2 = &temp2;
46631 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46632 }
46633 {
46634 arg3 = &temp3;
46635 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46636 }
46637 {
46638 PyThreadState* __tstate = wxPyBeginAllowThreads();
46639 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46640 wxPyEndAllowThreads(__tstate);
46641 if (PyErr_Occurred()) SWIG_fail;
46642 }
46643 resultobj = SWIG_Py_Void();
46644 return resultobj;
46645 fail:
46646 return NULL;
46647 }
46648
46649
46650 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46651 PyObject *resultobj = 0;
46652 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46653 wxSize result;
46654 void *argp1 = 0 ;
46655 int res1 = 0 ;
46656 PyObject *swig_obj[1] ;
46657
46658 if (!args) SWIG_fail;
46659 swig_obj[0] = args;
46660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46661 if (!SWIG_IsOK(res1)) {
46662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46663 }
46664 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46665 {
46666 PyThreadState* __tstate = wxPyBeginAllowThreads();
46667 result = (arg1)->GetMinSize();
46668 wxPyEndAllowThreads(__tstate);
46669 if (PyErr_Occurred()) SWIG_fail;
46670 }
46671 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46672 return resultobj;
46673 fail:
46674 return NULL;
46675 }
46676
46677
46678 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46679 PyObject *resultobj = 0;
46680 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46681 wxSize result;
46682 void *argp1 = 0 ;
46683 int res1 = 0 ;
46684 PyObject *swig_obj[1] ;
46685
46686 if (!args) SWIG_fail;
46687 swig_obj[0] = args;
46688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46689 if (!SWIG_IsOK(res1)) {
46690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46691 }
46692 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46693 {
46694 PyThreadState* __tstate = wxPyBeginAllowThreads();
46695 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46696 wxPyEndAllowThreads(__tstate);
46697 if (PyErr_Occurred()) SWIG_fail;
46698 }
46699 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46707 PyObject *resultobj = 0;
46708 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46709 int arg2 ;
46710 int arg3 ;
46711 void *argp1 = 0 ;
46712 int res1 = 0 ;
46713 int val2 ;
46714 int ecode2 = 0 ;
46715 int val3 ;
46716 int ecode3 = 0 ;
46717 PyObject * obj0 = 0 ;
46718 PyObject * obj1 = 0 ;
46719 PyObject * obj2 = 0 ;
46720 char * kwnames[] = {
46721 (char *) "self",(char *) "x",(char *) "y", NULL
46722 };
46723
46724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46726 if (!SWIG_IsOK(res1)) {
46727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46728 }
46729 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46730 ecode2 = SWIG_AsVal_int(obj1, &val2);
46731 if (!SWIG_IsOK(ecode2)) {
46732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46733 }
46734 arg2 = static_cast< int >(val2);
46735 ecode3 = SWIG_AsVal_int(obj2, &val3);
46736 if (!SWIG_IsOK(ecode3)) {
46737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46738 }
46739 arg3 = static_cast< int >(val3);
46740 {
46741 PyThreadState* __tstate = wxPyBeginAllowThreads();
46742 (arg1)->SetInitSize(arg2,arg3);
46743 wxPyEndAllowThreads(__tstate);
46744 if (PyErr_Occurred()) SWIG_fail;
46745 }
46746 resultobj = SWIG_Py_Void();
46747 return resultobj;
46748 fail:
46749 return NULL;
46750 }
46751
46752
46753 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46754 PyObject *resultobj = 0;
46755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46756 int arg2 ;
46757 int arg3 ;
46758 void *argp1 = 0 ;
46759 int res1 = 0 ;
46760 int val2 ;
46761 int ecode2 = 0 ;
46762 int val3 ;
46763 int ecode3 = 0 ;
46764 PyObject * obj0 = 0 ;
46765 PyObject * obj1 = 0 ;
46766 PyObject * obj2 = 0 ;
46767 char * kwnames[] = {
46768 (char *) "self",(char *) "width",(char *) "height", NULL
46769 };
46770
46771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46773 if (!SWIG_IsOK(res1)) {
46774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46775 }
46776 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46777 ecode2 = SWIG_AsVal_int(obj1, &val2);
46778 if (!SWIG_IsOK(ecode2)) {
46779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46780 }
46781 arg2 = static_cast< int >(val2);
46782 ecode3 = SWIG_AsVal_int(obj2, &val3);
46783 if (!SWIG_IsOK(ecode3)) {
46784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46785 }
46786 arg3 = static_cast< int >(val3);
46787 {
46788 PyThreadState* __tstate = wxPyBeginAllowThreads();
46789 (arg1)->SetRatio(arg2,arg3);
46790 wxPyEndAllowThreads(__tstate);
46791 if (PyErr_Occurred()) SWIG_fail;
46792 }
46793 resultobj = SWIG_Py_Void();
46794 return resultobj;
46795 fail:
46796 return NULL;
46797 }
46798
46799
46800 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46801 PyObject *resultobj = 0;
46802 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46803 wxSize *arg2 = 0 ;
46804 void *argp1 = 0 ;
46805 int res1 = 0 ;
46806 wxSize temp2 ;
46807 PyObject * obj0 = 0 ;
46808 PyObject * obj1 = 0 ;
46809 char * kwnames[] = {
46810 (char *) "self",(char *) "size", NULL
46811 };
46812
46813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46815 if (!SWIG_IsOK(res1)) {
46816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46817 }
46818 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46819 {
46820 arg2 = &temp2;
46821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46822 }
46823 {
46824 PyThreadState* __tstate = wxPyBeginAllowThreads();
46825 (arg1)->SetRatio((wxSize const &)*arg2);
46826 wxPyEndAllowThreads(__tstate);
46827 if (PyErr_Occurred()) SWIG_fail;
46828 }
46829 resultobj = SWIG_Py_Void();
46830 return resultobj;
46831 fail:
46832 return NULL;
46833 }
46834
46835
46836 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46837 PyObject *resultobj = 0;
46838 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46839 float arg2 ;
46840 void *argp1 = 0 ;
46841 int res1 = 0 ;
46842 float val2 ;
46843 int ecode2 = 0 ;
46844 PyObject * obj0 = 0 ;
46845 PyObject * obj1 = 0 ;
46846 char * kwnames[] = {
46847 (char *) "self",(char *) "ratio", NULL
46848 };
46849
46850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46852 if (!SWIG_IsOK(res1)) {
46853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46854 }
46855 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46856 ecode2 = SWIG_AsVal_float(obj1, &val2);
46857 if (!SWIG_IsOK(ecode2)) {
46858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46859 }
46860 arg2 = static_cast< float >(val2);
46861 {
46862 PyThreadState* __tstate = wxPyBeginAllowThreads();
46863 (arg1)->SetRatio(arg2);
46864 wxPyEndAllowThreads(__tstate);
46865 if (PyErr_Occurred()) SWIG_fail;
46866 }
46867 resultobj = SWIG_Py_Void();
46868 return resultobj;
46869 fail:
46870 return NULL;
46871 }
46872
46873
46874 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46875 PyObject *resultobj = 0;
46876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46877 float result;
46878 void *argp1 = 0 ;
46879 int res1 = 0 ;
46880 PyObject *swig_obj[1] ;
46881
46882 if (!args) SWIG_fail;
46883 swig_obj[0] = args;
46884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46885 if (!SWIG_IsOK(res1)) {
46886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46887 }
46888 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46889 {
46890 PyThreadState* __tstate = wxPyBeginAllowThreads();
46891 result = (float)(arg1)->GetRatio();
46892 wxPyEndAllowThreads(__tstate);
46893 if (PyErr_Occurred()) SWIG_fail;
46894 }
46895 resultobj = SWIG_From_float(static_cast< float >(result));
46896 return resultobj;
46897 fail:
46898 return NULL;
46899 }
46900
46901
46902 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46903 PyObject *resultobj = 0;
46904 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46905 wxRect result;
46906 void *argp1 = 0 ;
46907 int res1 = 0 ;
46908 PyObject *swig_obj[1] ;
46909
46910 if (!args) SWIG_fail;
46911 swig_obj[0] = args;
46912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46913 if (!SWIG_IsOK(res1)) {
46914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46915 }
46916 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46917 {
46918 PyThreadState* __tstate = wxPyBeginAllowThreads();
46919 result = (arg1)->GetRect();
46920 wxPyEndAllowThreads(__tstate);
46921 if (PyErr_Occurred()) SWIG_fail;
46922 }
46923 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46924 return resultobj;
46925 fail:
46926 return NULL;
46927 }
46928
46929
46930 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46931 PyObject *resultobj = 0;
46932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46933 bool result;
46934 void *argp1 = 0 ;
46935 int res1 = 0 ;
46936 PyObject *swig_obj[1] ;
46937
46938 if (!args) SWIG_fail;
46939 swig_obj[0] = args;
46940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46941 if (!SWIG_IsOK(res1)) {
46942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46943 }
46944 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46945 {
46946 PyThreadState* __tstate = wxPyBeginAllowThreads();
46947 result = (bool)(arg1)->IsWindow();
46948 wxPyEndAllowThreads(__tstate);
46949 if (PyErr_Occurred()) SWIG_fail;
46950 }
46951 {
46952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46953 }
46954 return resultobj;
46955 fail:
46956 return NULL;
46957 }
46958
46959
46960 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46961 PyObject *resultobj = 0;
46962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46963 bool result;
46964 void *argp1 = 0 ;
46965 int res1 = 0 ;
46966 PyObject *swig_obj[1] ;
46967
46968 if (!args) SWIG_fail;
46969 swig_obj[0] = args;
46970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46971 if (!SWIG_IsOK(res1)) {
46972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46973 }
46974 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46975 {
46976 PyThreadState* __tstate = wxPyBeginAllowThreads();
46977 result = (bool)(arg1)->IsSizer();
46978 wxPyEndAllowThreads(__tstate);
46979 if (PyErr_Occurred()) SWIG_fail;
46980 }
46981 {
46982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46983 }
46984 return resultobj;
46985 fail:
46986 return NULL;
46987 }
46988
46989
46990 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46991 PyObject *resultobj = 0;
46992 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46993 bool result;
46994 void *argp1 = 0 ;
46995 int res1 = 0 ;
46996 PyObject *swig_obj[1] ;
46997
46998 if (!args) SWIG_fail;
46999 swig_obj[0] = args;
47000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47001 if (!SWIG_IsOK(res1)) {
47002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47003 }
47004 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47005 {
47006 PyThreadState* __tstate = wxPyBeginAllowThreads();
47007 result = (bool)(arg1)->IsSpacer();
47008 wxPyEndAllowThreads(__tstate);
47009 if (PyErr_Occurred()) SWIG_fail;
47010 }
47011 {
47012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47013 }
47014 return resultobj;
47015 fail:
47016 return NULL;
47017 }
47018
47019
47020 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47021 PyObject *resultobj = 0;
47022 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47023 int arg2 ;
47024 void *argp1 = 0 ;
47025 int res1 = 0 ;
47026 int val2 ;
47027 int ecode2 = 0 ;
47028 PyObject * obj0 = 0 ;
47029 PyObject * obj1 = 0 ;
47030 char * kwnames[] = {
47031 (char *) "self",(char *) "proportion", NULL
47032 };
47033
47034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47036 if (!SWIG_IsOK(res1)) {
47037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47038 }
47039 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47040 ecode2 = SWIG_AsVal_int(obj1, &val2);
47041 if (!SWIG_IsOK(ecode2)) {
47042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47043 }
47044 arg2 = static_cast< int >(val2);
47045 {
47046 PyThreadState* __tstate = wxPyBeginAllowThreads();
47047 (arg1)->SetProportion(arg2);
47048 wxPyEndAllowThreads(__tstate);
47049 if (PyErr_Occurred()) SWIG_fail;
47050 }
47051 resultobj = SWIG_Py_Void();
47052 return resultobj;
47053 fail:
47054 return NULL;
47055 }
47056
47057
47058 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47059 PyObject *resultobj = 0;
47060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47061 int result;
47062 void *argp1 = 0 ;
47063 int res1 = 0 ;
47064 PyObject *swig_obj[1] ;
47065
47066 if (!args) SWIG_fail;
47067 swig_obj[0] = args;
47068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47069 if (!SWIG_IsOK(res1)) {
47070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47071 }
47072 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47073 {
47074 PyThreadState* __tstate = wxPyBeginAllowThreads();
47075 result = (int)(arg1)->GetProportion();
47076 wxPyEndAllowThreads(__tstate);
47077 if (PyErr_Occurred()) SWIG_fail;
47078 }
47079 resultobj = SWIG_From_int(static_cast< int >(result));
47080 return resultobj;
47081 fail:
47082 return NULL;
47083 }
47084
47085
47086 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47087 PyObject *resultobj = 0;
47088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47089 int arg2 ;
47090 void *argp1 = 0 ;
47091 int res1 = 0 ;
47092 int val2 ;
47093 int ecode2 = 0 ;
47094 PyObject * obj0 = 0 ;
47095 PyObject * obj1 = 0 ;
47096 char * kwnames[] = {
47097 (char *) "self",(char *) "flag", NULL
47098 };
47099
47100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47102 if (!SWIG_IsOK(res1)) {
47103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47104 }
47105 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47106 ecode2 = SWIG_AsVal_int(obj1, &val2);
47107 if (!SWIG_IsOK(ecode2)) {
47108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47109 }
47110 arg2 = static_cast< int >(val2);
47111 {
47112 PyThreadState* __tstate = wxPyBeginAllowThreads();
47113 (arg1)->SetFlag(arg2);
47114 wxPyEndAllowThreads(__tstate);
47115 if (PyErr_Occurred()) SWIG_fail;
47116 }
47117 resultobj = SWIG_Py_Void();
47118 return resultobj;
47119 fail:
47120 return NULL;
47121 }
47122
47123
47124 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47125 PyObject *resultobj = 0;
47126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47127 int result;
47128 void *argp1 = 0 ;
47129 int res1 = 0 ;
47130 PyObject *swig_obj[1] ;
47131
47132 if (!args) SWIG_fail;
47133 swig_obj[0] = args;
47134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47135 if (!SWIG_IsOK(res1)) {
47136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47137 }
47138 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47139 {
47140 PyThreadState* __tstate = wxPyBeginAllowThreads();
47141 result = (int)(arg1)->GetFlag();
47142 wxPyEndAllowThreads(__tstate);
47143 if (PyErr_Occurred()) SWIG_fail;
47144 }
47145 resultobj = SWIG_From_int(static_cast< int >(result));
47146 return resultobj;
47147 fail:
47148 return NULL;
47149 }
47150
47151
47152 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47153 PyObject *resultobj = 0;
47154 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47155 int arg2 ;
47156 void *argp1 = 0 ;
47157 int res1 = 0 ;
47158 int val2 ;
47159 int ecode2 = 0 ;
47160 PyObject * obj0 = 0 ;
47161 PyObject * obj1 = 0 ;
47162 char * kwnames[] = {
47163 (char *) "self",(char *) "border", NULL
47164 };
47165
47166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47168 if (!SWIG_IsOK(res1)) {
47169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47170 }
47171 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47172 ecode2 = SWIG_AsVal_int(obj1, &val2);
47173 if (!SWIG_IsOK(ecode2)) {
47174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47175 }
47176 arg2 = static_cast< int >(val2);
47177 {
47178 PyThreadState* __tstate = wxPyBeginAllowThreads();
47179 (arg1)->SetBorder(arg2);
47180 wxPyEndAllowThreads(__tstate);
47181 if (PyErr_Occurred()) SWIG_fail;
47182 }
47183 resultobj = SWIG_Py_Void();
47184 return resultobj;
47185 fail:
47186 return NULL;
47187 }
47188
47189
47190 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47191 PyObject *resultobj = 0;
47192 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47193 int result;
47194 void *argp1 = 0 ;
47195 int res1 = 0 ;
47196 PyObject *swig_obj[1] ;
47197
47198 if (!args) SWIG_fail;
47199 swig_obj[0] = args;
47200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47201 if (!SWIG_IsOK(res1)) {
47202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47203 }
47204 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47205 {
47206 PyThreadState* __tstate = wxPyBeginAllowThreads();
47207 result = (int)(arg1)->GetBorder();
47208 wxPyEndAllowThreads(__tstate);
47209 if (PyErr_Occurred()) SWIG_fail;
47210 }
47211 resultobj = SWIG_From_int(static_cast< int >(result));
47212 return resultobj;
47213 fail:
47214 return NULL;
47215 }
47216
47217
47218 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47219 PyObject *resultobj = 0;
47220 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47221 wxWindow *result = 0 ;
47222 void *argp1 = 0 ;
47223 int res1 = 0 ;
47224 PyObject *swig_obj[1] ;
47225
47226 if (!args) SWIG_fail;
47227 swig_obj[0] = args;
47228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47229 if (!SWIG_IsOK(res1)) {
47230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47231 }
47232 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47233 {
47234 PyThreadState* __tstate = wxPyBeginAllowThreads();
47235 result = (wxWindow *)(arg1)->GetWindow();
47236 wxPyEndAllowThreads(__tstate);
47237 if (PyErr_Occurred()) SWIG_fail;
47238 }
47239 {
47240 resultobj = wxPyMake_wxObject(result, 0);
47241 }
47242 return resultobj;
47243 fail:
47244 return NULL;
47245 }
47246
47247
47248 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47249 PyObject *resultobj = 0;
47250 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47251 wxWindow *arg2 = (wxWindow *) 0 ;
47252 void *argp1 = 0 ;
47253 int res1 = 0 ;
47254 void *argp2 = 0 ;
47255 int res2 = 0 ;
47256 PyObject * obj0 = 0 ;
47257 PyObject * obj1 = 0 ;
47258 char * kwnames[] = {
47259 (char *) "self",(char *) "window", NULL
47260 };
47261
47262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47264 if (!SWIG_IsOK(res1)) {
47265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47266 }
47267 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47269 if (!SWIG_IsOK(res2)) {
47270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47271 }
47272 arg2 = reinterpret_cast< wxWindow * >(argp2);
47273 {
47274 PyThreadState* __tstate = wxPyBeginAllowThreads();
47275 (arg1)->SetWindow(arg2);
47276 wxPyEndAllowThreads(__tstate);
47277 if (PyErr_Occurred()) SWIG_fail;
47278 }
47279 resultobj = SWIG_Py_Void();
47280 return resultobj;
47281 fail:
47282 return NULL;
47283 }
47284
47285
47286 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47287 PyObject *resultobj = 0;
47288 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47289 wxSizer *result = 0 ;
47290 void *argp1 = 0 ;
47291 int res1 = 0 ;
47292 PyObject *swig_obj[1] ;
47293
47294 if (!args) SWIG_fail;
47295 swig_obj[0] = args;
47296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47297 if (!SWIG_IsOK(res1)) {
47298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47299 }
47300 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47301 {
47302 PyThreadState* __tstate = wxPyBeginAllowThreads();
47303 result = (wxSizer *)(arg1)->GetSizer();
47304 wxPyEndAllowThreads(__tstate);
47305 if (PyErr_Occurred()) SWIG_fail;
47306 }
47307 {
47308 resultobj = wxPyMake_wxObject(result, (bool)0);
47309 }
47310 return resultobj;
47311 fail:
47312 return NULL;
47313 }
47314
47315
47316 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47317 PyObject *resultobj = 0;
47318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47319 wxSizer *arg2 = (wxSizer *) 0 ;
47320 void *argp1 = 0 ;
47321 int res1 = 0 ;
47322 int res2 = 0 ;
47323 PyObject * obj0 = 0 ;
47324 PyObject * obj1 = 0 ;
47325 char * kwnames[] = {
47326 (char *) "self",(char *) "sizer", NULL
47327 };
47328
47329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47331 if (!SWIG_IsOK(res1)) {
47332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47333 }
47334 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47335 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47336 if (!SWIG_IsOK(res2)) {
47337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47338 }
47339 {
47340 PyThreadState* __tstate = wxPyBeginAllowThreads();
47341 (arg1)->SetSizer(arg2);
47342 wxPyEndAllowThreads(__tstate);
47343 if (PyErr_Occurred()) SWIG_fail;
47344 }
47345 resultobj = SWIG_Py_Void();
47346 return resultobj;
47347 fail:
47348 return NULL;
47349 }
47350
47351
47352 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47353 PyObject *resultobj = 0;
47354 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47355 wxSize result;
47356 void *argp1 = 0 ;
47357 int res1 = 0 ;
47358 PyObject *swig_obj[1] ;
47359
47360 if (!args) SWIG_fail;
47361 swig_obj[0] = args;
47362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47363 if (!SWIG_IsOK(res1)) {
47364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47365 }
47366 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47367 {
47368 PyThreadState* __tstate = wxPyBeginAllowThreads();
47369 result = (arg1)->GetSpacer();
47370 wxPyEndAllowThreads(__tstate);
47371 if (PyErr_Occurred()) SWIG_fail;
47372 }
47373 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47374 return resultobj;
47375 fail:
47376 return NULL;
47377 }
47378
47379
47380 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47381 PyObject *resultobj = 0;
47382 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47383 wxSize *arg2 = 0 ;
47384 void *argp1 = 0 ;
47385 int res1 = 0 ;
47386 wxSize temp2 ;
47387 PyObject * obj0 = 0 ;
47388 PyObject * obj1 = 0 ;
47389 char * kwnames[] = {
47390 (char *) "self",(char *) "size", NULL
47391 };
47392
47393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47395 if (!SWIG_IsOK(res1)) {
47396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47397 }
47398 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47399 {
47400 arg2 = &temp2;
47401 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47402 }
47403 {
47404 PyThreadState* __tstate = wxPyBeginAllowThreads();
47405 (arg1)->SetSpacer((wxSize const &)*arg2);
47406 wxPyEndAllowThreads(__tstate);
47407 if (PyErr_Occurred()) SWIG_fail;
47408 }
47409 resultobj = SWIG_Py_Void();
47410 return resultobj;
47411 fail:
47412 return NULL;
47413 }
47414
47415
47416 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47417 PyObject *resultobj = 0;
47418 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47419 bool arg2 ;
47420 void *argp1 = 0 ;
47421 int res1 = 0 ;
47422 bool val2 ;
47423 int ecode2 = 0 ;
47424 PyObject * obj0 = 0 ;
47425 PyObject * obj1 = 0 ;
47426 char * kwnames[] = {
47427 (char *) "self",(char *) "show", NULL
47428 };
47429
47430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47432 if (!SWIG_IsOK(res1)) {
47433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47434 }
47435 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47437 if (!SWIG_IsOK(ecode2)) {
47438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47439 }
47440 arg2 = static_cast< bool >(val2);
47441 {
47442 PyThreadState* __tstate = wxPyBeginAllowThreads();
47443 (arg1)->Show(arg2);
47444 wxPyEndAllowThreads(__tstate);
47445 if (PyErr_Occurred()) SWIG_fail;
47446 }
47447 resultobj = SWIG_Py_Void();
47448 return resultobj;
47449 fail:
47450 return NULL;
47451 }
47452
47453
47454 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47455 PyObject *resultobj = 0;
47456 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47457 bool result;
47458 void *argp1 = 0 ;
47459 int res1 = 0 ;
47460 PyObject *swig_obj[1] ;
47461
47462 if (!args) SWIG_fail;
47463 swig_obj[0] = args;
47464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47465 if (!SWIG_IsOK(res1)) {
47466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47467 }
47468 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47469 {
47470 PyThreadState* __tstate = wxPyBeginAllowThreads();
47471 result = (bool)(arg1)->IsShown();
47472 wxPyEndAllowThreads(__tstate);
47473 if (PyErr_Occurred()) SWIG_fail;
47474 }
47475 {
47476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47477 }
47478 return resultobj;
47479 fail:
47480 return NULL;
47481 }
47482
47483
47484 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47485 PyObject *resultobj = 0;
47486 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47487 wxPoint result;
47488 void *argp1 = 0 ;
47489 int res1 = 0 ;
47490 PyObject *swig_obj[1] ;
47491
47492 if (!args) SWIG_fail;
47493 swig_obj[0] = args;
47494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47495 if (!SWIG_IsOK(res1)) {
47496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47497 }
47498 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47499 {
47500 PyThreadState* __tstate = wxPyBeginAllowThreads();
47501 result = (arg1)->GetPosition();
47502 wxPyEndAllowThreads(__tstate);
47503 if (PyErr_Occurred()) SWIG_fail;
47504 }
47505 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47506 return resultobj;
47507 fail:
47508 return NULL;
47509 }
47510
47511
47512 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47513 PyObject *resultobj = 0;
47514 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47515 PyObject *result = 0 ;
47516 void *argp1 = 0 ;
47517 int res1 = 0 ;
47518 PyObject *swig_obj[1] ;
47519
47520 if (!args) SWIG_fail;
47521 swig_obj[0] = args;
47522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47523 if (!SWIG_IsOK(res1)) {
47524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47525 }
47526 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47527 {
47528 PyThreadState* __tstate = wxPyBeginAllowThreads();
47529 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47530 wxPyEndAllowThreads(__tstate);
47531 if (PyErr_Occurred()) SWIG_fail;
47532 }
47533 resultobj = result;
47534 return resultobj;
47535 fail:
47536 return NULL;
47537 }
47538
47539
47540 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47541 PyObject *resultobj = 0;
47542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47543 PyObject *arg2 = (PyObject *) 0 ;
47544 void *argp1 = 0 ;
47545 int res1 = 0 ;
47546 PyObject * obj0 = 0 ;
47547 PyObject * obj1 = 0 ;
47548 char * kwnames[] = {
47549 (char *) "self",(char *) "userData", NULL
47550 };
47551
47552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47554 if (!SWIG_IsOK(res1)) {
47555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47556 }
47557 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47558 arg2 = obj1;
47559 {
47560 PyThreadState* __tstate = wxPyBeginAllowThreads();
47561 wxSizerItem_SetUserData(arg1,arg2);
47562 wxPyEndAllowThreads(__tstate);
47563 if (PyErr_Occurred()) SWIG_fail;
47564 }
47565 resultobj = SWIG_Py_Void();
47566 return resultobj;
47567 fail:
47568 return NULL;
47569 }
47570
47571
47572 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47573 PyObject *obj;
47574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47575 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47576 return SWIG_Py_Void();
47577 }
47578
47579 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47580 return SWIG_Python_InitShadowInstance(args);
47581 }
47582
47583 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47584 PyObject *resultobj = 0;
47585 wxSizer *arg1 = (wxSizer *) 0 ;
47586 void *argp1 = 0 ;
47587 int res1 = 0 ;
47588 PyObject *swig_obj[1] ;
47589
47590 if (!args) SWIG_fail;
47591 swig_obj[0] = args;
47592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47593 if (!SWIG_IsOK(res1)) {
47594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47595 }
47596 arg1 = reinterpret_cast< wxSizer * >(argp1);
47597 {
47598 PyThreadState* __tstate = wxPyBeginAllowThreads();
47599 delete arg1;
47600
47601 wxPyEndAllowThreads(__tstate);
47602 if (PyErr_Occurred()) SWIG_fail;
47603 }
47604 resultobj = SWIG_Py_Void();
47605 return resultobj;
47606 fail:
47607 return NULL;
47608 }
47609
47610
47611 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47612 PyObject *resultobj = 0;
47613 wxSizer *arg1 = (wxSizer *) 0 ;
47614 PyObject *arg2 = (PyObject *) 0 ;
47615 void *argp1 = 0 ;
47616 int res1 = 0 ;
47617 PyObject * obj0 = 0 ;
47618 PyObject * obj1 = 0 ;
47619 char * kwnames[] = {
47620 (char *) "self",(char *) "_self", NULL
47621 };
47622
47623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47625 if (!SWIG_IsOK(res1)) {
47626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47627 }
47628 arg1 = reinterpret_cast< wxSizer * >(argp1);
47629 arg2 = obj1;
47630 {
47631 PyThreadState* __tstate = wxPyBeginAllowThreads();
47632 wxSizer__setOORInfo(arg1,arg2);
47633 wxPyEndAllowThreads(__tstate);
47634 if (PyErr_Occurred()) SWIG_fail;
47635 }
47636 resultobj = SWIG_Py_Void();
47637 return resultobj;
47638 fail:
47639 return NULL;
47640 }
47641
47642
47643 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47644 PyObject *resultobj = 0;
47645 wxSizer *arg1 = (wxSizer *) 0 ;
47646 PyObject *arg2 = (PyObject *) 0 ;
47647 int arg3 = (int) 0 ;
47648 int arg4 = (int) 0 ;
47649 int arg5 = (int) 0 ;
47650 PyObject *arg6 = (PyObject *) NULL ;
47651 wxSizerItem *result = 0 ;
47652 void *argp1 = 0 ;
47653 int res1 = 0 ;
47654 int val3 ;
47655 int ecode3 = 0 ;
47656 int val4 ;
47657 int ecode4 = 0 ;
47658 int val5 ;
47659 int ecode5 = 0 ;
47660 PyObject * obj0 = 0 ;
47661 PyObject * obj1 = 0 ;
47662 PyObject * obj2 = 0 ;
47663 PyObject * obj3 = 0 ;
47664 PyObject * obj4 = 0 ;
47665 PyObject * obj5 = 0 ;
47666 char * kwnames[] = {
47667 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47668 };
47669
47670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47672 if (!SWIG_IsOK(res1)) {
47673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47674 }
47675 arg1 = reinterpret_cast< wxSizer * >(argp1);
47676 arg2 = obj1;
47677 if (obj2) {
47678 ecode3 = SWIG_AsVal_int(obj2, &val3);
47679 if (!SWIG_IsOK(ecode3)) {
47680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47681 }
47682 arg3 = static_cast< int >(val3);
47683 }
47684 if (obj3) {
47685 ecode4 = SWIG_AsVal_int(obj3, &val4);
47686 if (!SWIG_IsOK(ecode4)) {
47687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47688 }
47689 arg4 = static_cast< int >(val4);
47690 }
47691 if (obj4) {
47692 ecode5 = SWIG_AsVal_int(obj4, &val5);
47693 if (!SWIG_IsOK(ecode5)) {
47694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47695 }
47696 arg5 = static_cast< int >(val5);
47697 }
47698 if (obj5) {
47699 arg6 = obj5;
47700 }
47701 {
47702 PyThreadState* __tstate = wxPyBeginAllowThreads();
47703 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47704 wxPyEndAllowThreads(__tstate);
47705 if (PyErr_Occurred()) SWIG_fail;
47706 }
47707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47708 return resultobj;
47709 fail:
47710 return NULL;
47711 }
47712
47713
47714 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47715 PyObject *resultobj = 0;
47716 wxSizer *arg1 = (wxSizer *) 0 ;
47717 int arg2 ;
47718 PyObject *arg3 = (PyObject *) 0 ;
47719 int arg4 = (int) 0 ;
47720 int arg5 = (int) 0 ;
47721 int arg6 = (int) 0 ;
47722 PyObject *arg7 = (PyObject *) NULL ;
47723 wxSizerItem *result = 0 ;
47724 void *argp1 = 0 ;
47725 int res1 = 0 ;
47726 int val2 ;
47727 int ecode2 = 0 ;
47728 int val4 ;
47729 int ecode4 = 0 ;
47730 int val5 ;
47731 int ecode5 = 0 ;
47732 int val6 ;
47733 int ecode6 = 0 ;
47734 PyObject * obj0 = 0 ;
47735 PyObject * obj1 = 0 ;
47736 PyObject * obj2 = 0 ;
47737 PyObject * obj3 = 0 ;
47738 PyObject * obj4 = 0 ;
47739 PyObject * obj5 = 0 ;
47740 PyObject * obj6 = 0 ;
47741 char * kwnames[] = {
47742 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47743 };
47744
47745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47747 if (!SWIG_IsOK(res1)) {
47748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47749 }
47750 arg1 = reinterpret_cast< wxSizer * >(argp1);
47751 ecode2 = SWIG_AsVal_int(obj1, &val2);
47752 if (!SWIG_IsOK(ecode2)) {
47753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47754 }
47755 arg2 = static_cast< int >(val2);
47756 arg3 = obj2;
47757 if (obj3) {
47758 ecode4 = SWIG_AsVal_int(obj3, &val4);
47759 if (!SWIG_IsOK(ecode4)) {
47760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47761 }
47762 arg4 = static_cast< int >(val4);
47763 }
47764 if (obj4) {
47765 ecode5 = SWIG_AsVal_int(obj4, &val5);
47766 if (!SWIG_IsOK(ecode5)) {
47767 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47768 }
47769 arg5 = static_cast< int >(val5);
47770 }
47771 if (obj5) {
47772 ecode6 = SWIG_AsVal_int(obj5, &val6);
47773 if (!SWIG_IsOK(ecode6)) {
47774 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47775 }
47776 arg6 = static_cast< int >(val6);
47777 }
47778 if (obj6) {
47779 arg7 = obj6;
47780 }
47781 {
47782 PyThreadState* __tstate = wxPyBeginAllowThreads();
47783 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47784 wxPyEndAllowThreads(__tstate);
47785 if (PyErr_Occurred()) SWIG_fail;
47786 }
47787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47788 return resultobj;
47789 fail:
47790 return NULL;
47791 }
47792
47793
47794 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47795 PyObject *resultobj = 0;
47796 wxSizer *arg1 = (wxSizer *) 0 ;
47797 PyObject *arg2 = (PyObject *) 0 ;
47798 int arg3 = (int) 0 ;
47799 int arg4 = (int) 0 ;
47800 int arg5 = (int) 0 ;
47801 PyObject *arg6 = (PyObject *) NULL ;
47802 wxSizerItem *result = 0 ;
47803 void *argp1 = 0 ;
47804 int res1 = 0 ;
47805 int val3 ;
47806 int ecode3 = 0 ;
47807 int val4 ;
47808 int ecode4 = 0 ;
47809 int val5 ;
47810 int ecode5 = 0 ;
47811 PyObject * obj0 = 0 ;
47812 PyObject * obj1 = 0 ;
47813 PyObject * obj2 = 0 ;
47814 PyObject * obj3 = 0 ;
47815 PyObject * obj4 = 0 ;
47816 PyObject * obj5 = 0 ;
47817 char * kwnames[] = {
47818 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47819 };
47820
47821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47823 if (!SWIG_IsOK(res1)) {
47824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47825 }
47826 arg1 = reinterpret_cast< wxSizer * >(argp1);
47827 arg2 = obj1;
47828 if (obj2) {
47829 ecode3 = SWIG_AsVal_int(obj2, &val3);
47830 if (!SWIG_IsOK(ecode3)) {
47831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47832 }
47833 arg3 = static_cast< int >(val3);
47834 }
47835 if (obj3) {
47836 ecode4 = SWIG_AsVal_int(obj3, &val4);
47837 if (!SWIG_IsOK(ecode4)) {
47838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47839 }
47840 arg4 = static_cast< int >(val4);
47841 }
47842 if (obj4) {
47843 ecode5 = SWIG_AsVal_int(obj4, &val5);
47844 if (!SWIG_IsOK(ecode5)) {
47845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47846 }
47847 arg5 = static_cast< int >(val5);
47848 }
47849 if (obj5) {
47850 arg6 = obj5;
47851 }
47852 {
47853 PyThreadState* __tstate = wxPyBeginAllowThreads();
47854 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47855 wxPyEndAllowThreads(__tstate);
47856 if (PyErr_Occurred()) SWIG_fail;
47857 }
47858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47859 return resultobj;
47860 fail:
47861 return NULL;
47862 }
47863
47864
47865 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47866 PyObject *resultobj = 0;
47867 wxSizer *arg1 = (wxSizer *) 0 ;
47868 PyObject *arg2 = (PyObject *) 0 ;
47869 bool result;
47870 void *argp1 = 0 ;
47871 int res1 = 0 ;
47872 PyObject * obj0 = 0 ;
47873 PyObject * obj1 = 0 ;
47874 char * kwnames[] = {
47875 (char *) "self",(char *) "item", NULL
47876 };
47877
47878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47880 if (!SWIG_IsOK(res1)) {
47881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47882 }
47883 arg1 = reinterpret_cast< wxSizer * >(argp1);
47884 arg2 = obj1;
47885 {
47886 PyThreadState* __tstate = wxPyBeginAllowThreads();
47887 result = (bool)wxSizer_Remove(arg1,arg2);
47888 wxPyEndAllowThreads(__tstate);
47889 if (PyErr_Occurred()) SWIG_fail;
47890 }
47891 {
47892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47893 }
47894 return resultobj;
47895 fail:
47896 return NULL;
47897 }
47898
47899
47900 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47901 PyObject *resultobj = 0;
47902 wxSizer *arg1 = (wxSizer *) 0 ;
47903 PyObject *arg2 = (PyObject *) 0 ;
47904 bool result;
47905 void *argp1 = 0 ;
47906 int res1 = 0 ;
47907 PyObject * obj0 = 0 ;
47908 PyObject * obj1 = 0 ;
47909 char * kwnames[] = {
47910 (char *) "self",(char *) "item", NULL
47911 };
47912
47913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47915 if (!SWIG_IsOK(res1)) {
47916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47917 }
47918 arg1 = reinterpret_cast< wxSizer * >(argp1);
47919 arg2 = obj1;
47920 {
47921 PyThreadState* __tstate = wxPyBeginAllowThreads();
47922 result = (bool)wxSizer_Detach(arg1,arg2);
47923 wxPyEndAllowThreads(__tstate);
47924 if (PyErr_Occurred()) SWIG_fail;
47925 }
47926 {
47927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47928 }
47929 return resultobj;
47930 fail:
47931 return NULL;
47932 }
47933
47934
47935 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47936 PyObject *resultobj = 0;
47937 wxSizer *arg1 = (wxSizer *) 0 ;
47938 PyObject *arg2 = (PyObject *) 0 ;
47939 wxSizerItem *result = 0 ;
47940 void *argp1 = 0 ;
47941 int res1 = 0 ;
47942 PyObject * obj0 = 0 ;
47943 PyObject * obj1 = 0 ;
47944 char * kwnames[] = {
47945 (char *) "self",(char *) "item", NULL
47946 };
47947
47948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47950 if (!SWIG_IsOK(res1)) {
47951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47952 }
47953 arg1 = reinterpret_cast< wxSizer * >(argp1);
47954 arg2 = obj1;
47955 {
47956 PyThreadState* __tstate = wxPyBeginAllowThreads();
47957 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47958 wxPyEndAllowThreads(__tstate);
47959 if (PyErr_Occurred()) SWIG_fail;
47960 }
47961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47962 return resultobj;
47963 fail:
47964 return NULL;
47965 }
47966
47967
47968 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47969 PyObject *resultobj = 0;
47970 wxSizer *arg1 = (wxSizer *) 0 ;
47971 PyObject *arg2 = (PyObject *) 0 ;
47972 wxSize *arg3 = 0 ;
47973 void *argp1 = 0 ;
47974 int res1 = 0 ;
47975 wxSize temp3 ;
47976 PyObject * obj0 = 0 ;
47977 PyObject * obj1 = 0 ;
47978 PyObject * obj2 = 0 ;
47979 char * kwnames[] = {
47980 (char *) "self",(char *) "item",(char *) "size", NULL
47981 };
47982
47983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47985 if (!SWIG_IsOK(res1)) {
47986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47987 }
47988 arg1 = reinterpret_cast< wxSizer * >(argp1);
47989 arg2 = obj1;
47990 {
47991 arg3 = &temp3;
47992 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47993 }
47994 {
47995 PyThreadState* __tstate = wxPyBeginAllowThreads();
47996 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47997 wxPyEndAllowThreads(__tstate);
47998 if (PyErr_Occurred()) SWIG_fail;
47999 }
48000 resultobj = SWIG_Py_Void();
48001 return resultobj;
48002 fail:
48003 return NULL;
48004 }
48005
48006
48007 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48008 PyObject *resultobj = 0;
48009 wxSizer *arg1 = (wxSizer *) 0 ;
48010 wxWindow *arg2 = (wxWindow *) 0 ;
48011 wxWindow *arg3 = (wxWindow *) 0 ;
48012 bool arg4 = (bool) false ;
48013 bool result;
48014 void *argp1 = 0 ;
48015 int res1 = 0 ;
48016 void *argp2 = 0 ;
48017 int res2 = 0 ;
48018 void *argp3 = 0 ;
48019 int res3 = 0 ;
48020 bool val4 ;
48021 int ecode4 = 0 ;
48022 PyObject * obj0 = 0 ;
48023 PyObject * obj1 = 0 ;
48024 PyObject * obj2 = 0 ;
48025 PyObject * obj3 = 0 ;
48026 char * kwnames[] = {
48027 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48028 };
48029
48030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48032 if (!SWIG_IsOK(res1)) {
48033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48034 }
48035 arg1 = reinterpret_cast< wxSizer * >(argp1);
48036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48037 if (!SWIG_IsOK(res2)) {
48038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48039 }
48040 arg2 = reinterpret_cast< wxWindow * >(argp2);
48041 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48042 if (!SWIG_IsOK(res3)) {
48043 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48044 }
48045 arg3 = reinterpret_cast< wxWindow * >(argp3);
48046 if (obj3) {
48047 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48048 if (!SWIG_IsOK(ecode4)) {
48049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48050 }
48051 arg4 = static_cast< bool >(val4);
48052 }
48053 {
48054 PyThreadState* __tstate = wxPyBeginAllowThreads();
48055 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48056 wxPyEndAllowThreads(__tstate);
48057 if (PyErr_Occurred()) SWIG_fail;
48058 }
48059 {
48060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48061 }
48062 return resultobj;
48063 fail:
48064 return NULL;
48065 }
48066
48067
48068 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48069 PyObject *resultobj = 0;
48070 wxSizer *arg1 = (wxSizer *) 0 ;
48071 wxSizer *arg2 = (wxSizer *) 0 ;
48072 wxSizer *arg3 = (wxSizer *) 0 ;
48073 bool arg4 = (bool) false ;
48074 bool result;
48075 void *argp1 = 0 ;
48076 int res1 = 0 ;
48077 void *argp2 = 0 ;
48078 int res2 = 0 ;
48079 void *argp3 = 0 ;
48080 int res3 = 0 ;
48081 bool val4 ;
48082 int ecode4 = 0 ;
48083 PyObject * obj0 = 0 ;
48084 PyObject * obj1 = 0 ;
48085 PyObject * obj2 = 0 ;
48086 PyObject * obj3 = 0 ;
48087 char * kwnames[] = {
48088 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48089 };
48090
48091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48093 if (!SWIG_IsOK(res1)) {
48094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48095 }
48096 arg1 = reinterpret_cast< wxSizer * >(argp1);
48097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48098 if (!SWIG_IsOK(res2)) {
48099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48100 }
48101 arg2 = reinterpret_cast< wxSizer * >(argp2);
48102 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48103 if (!SWIG_IsOK(res3)) {
48104 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48105 }
48106 arg3 = reinterpret_cast< wxSizer * >(argp3);
48107 if (obj3) {
48108 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48109 if (!SWIG_IsOK(ecode4)) {
48110 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48111 }
48112 arg4 = static_cast< bool >(val4);
48113 }
48114 {
48115 PyThreadState* __tstate = wxPyBeginAllowThreads();
48116 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48117 wxPyEndAllowThreads(__tstate);
48118 if (PyErr_Occurred()) SWIG_fail;
48119 }
48120 {
48121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48122 }
48123 return resultobj;
48124 fail:
48125 return NULL;
48126 }
48127
48128
48129 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48130 PyObject *resultobj = 0;
48131 wxSizer *arg1 = (wxSizer *) 0 ;
48132 size_t arg2 ;
48133 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48134 bool result;
48135 void *argp1 = 0 ;
48136 int res1 = 0 ;
48137 size_t val2 ;
48138 int ecode2 = 0 ;
48139 void *argp3 = 0 ;
48140 int res3 = 0 ;
48141 PyObject * obj0 = 0 ;
48142 PyObject * obj1 = 0 ;
48143 PyObject * obj2 = 0 ;
48144 char * kwnames[] = {
48145 (char *) "self",(char *) "index",(char *) "newitem", NULL
48146 };
48147
48148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48150 if (!SWIG_IsOK(res1)) {
48151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48152 }
48153 arg1 = reinterpret_cast< wxSizer * >(argp1);
48154 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48155 if (!SWIG_IsOK(ecode2)) {
48156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48157 }
48158 arg2 = static_cast< size_t >(val2);
48159 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48160 if (!SWIG_IsOK(res3)) {
48161 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48162 }
48163 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48164 {
48165 PyThreadState* __tstate = wxPyBeginAllowThreads();
48166 result = (bool)(arg1)->Replace(arg2,arg3);
48167 wxPyEndAllowThreads(__tstate);
48168 if (PyErr_Occurred()) SWIG_fail;
48169 }
48170 {
48171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48172 }
48173 return resultobj;
48174 fail:
48175 return NULL;
48176 }
48177
48178
48179 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48180 PyObject *resultobj = 0;
48181 wxSizer *arg1 = (wxSizer *) 0 ;
48182 wxWindow *arg2 = (wxWindow *) 0 ;
48183 void *argp1 = 0 ;
48184 int res1 = 0 ;
48185 void *argp2 = 0 ;
48186 int res2 = 0 ;
48187 PyObject * obj0 = 0 ;
48188 PyObject * obj1 = 0 ;
48189 char * kwnames[] = {
48190 (char *) "self",(char *) "window", NULL
48191 };
48192
48193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48195 if (!SWIG_IsOK(res1)) {
48196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48197 }
48198 arg1 = reinterpret_cast< wxSizer * >(argp1);
48199 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48200 if (!SWIG_IsOK(res2)) {
48201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48202 }
48203 arg2 = reinterpret_cast< wxWindow * >(argp2);
48204 {
48205 PyThreadState* __tstate = wxPyBeginAllowThreads();
48206 (arg1)->SetContainingWindow(arg2);
48207 wxPyEndAllowThreads(__tstate);
48208 if (PyErr_Occurred()) SWIG_fail;
48209 }
48210 resultobj = SWIG_Py_Void();
48211 return resultobj;
48212 fail:
48213 return NULL;
48214 }
48215
48216
48217 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48218 PyObject *resultobj = 0;
48219 wxSizer *arg1 = (wxSizer *) 0 ;
48220 wxWindow *result = 0 ;
48221 void *argp1 = 0 ;
48222 int res1 = 0 ;
48223 PyObject *swig_obj[1] ;
48224
48225 if (!args) SWIG_fail;
48226 swig_obj[0] = args;
48227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48228 if (!SWIG_IsOK(res1)) {
48229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48230 }
48231 arg1 = reinterpret_cast< wxSizer * >(argp1);
48232 {
48233 PyThreadState* __tstate = wxPyBeginAllowThreads();
48234 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48235 wxPyEndAllowThreads(__tstate);
48236 if (PyErr_Occurred()) SWIG_fail;
48237 }
48238 {
48239 resultobj = wxPyMake_wxObject(result, 0);
48240 }
48241 return resultobj;
48242 fail:
48243 return NULL;
48244 }
48245
48246
48247 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48248 PyObject *resultobj = 0;
48249 wxSizer *arg1 = (wxSizer *) 0 ;
48250 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48251 wxSizerItem *result = 0 ;
48252 void *argp1 = 0 ;
48253 int res1 = 0 ;
48254 int res2 = 0 ;
48255 PyObject * obj0 = 0 ;
48256 PyObject * obj1 = 0 ;
48257 char * kwnames[] = {
48258 (char *) "self",(char *) "item", NULL
48259 };
48260
48261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48263 if (!SWIG_IsOK(res1)) {
48264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48265 }
48266 arg1 = reinterpret_cast< wxSizer * >(argp1);
48267 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48268 if (!SWIG_IsOK(res2)) {
48269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48270 }
48271 {
48272 PyThreadState* __tstate = wxPyBeginAllowThreads();
48273 result = (wxSizerItem *)(arg1)->Add(arg2);
48274 wxPyEndAllowThreads(__tstate);
48275 if (PyErr_Occurred()) SWIG_fail;
48276 }
48277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48278 return resultobj;
48279 fail:
48280 return NULL;
48281 }
48282
48283
48284 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48285 PyObject *resultobj = 0;
48286 wxSizer *arg1 = (wxSizer *) 0 ;
48287 size_t arg2 ;
48288 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48289 wxSizerItem *result = 0 ;
48290 void *argp1 = 0 ;
48291 int res1 = 0 ;
48292 size_t val2 ;
48293 int ecode2 = 0 ;
48294 int res3 = 0 ;
48295 PyObject * obj0 = 0 ;
48296 PyObject * obj1 = 0 ;
48297 PyObject * obj2 = 0 ;
48298 char * kwnames[] = {
48299 (char *) "self",(char *) "index",(char *) "item", NULL
48300 };
48301
48302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48304 if (!SWIG_IsOK(res1)) {
48305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48306 }
48307 arg1 = reinterpret_cast< wxSizer * >(argp1);
48308 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48309 if (!SWIG_IsOK(ecode2)) {
48310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48311 }
48312 arg2 = static_cast< size_t >(val2);
48313 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48314 if (!SWIG_IsOK(res3)) {
48315 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48316 }
48317 {
48318 PyThreadState* __tstate = wxPyBeginAllowThreads();
48319 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48320 wxPyEndAllowThreads(__tstate);
48321 if (PyErr_Occurred()) SWIG_fail;
48322 }
48323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48324 return resultobj;
48325 fail:
48326 return NULL;
48327 }
48328
48329
48330 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48331 PyObject *resultobj = 0;
48332 wxSizer *arg1 = (wxSizer *) 0 ;
48333 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48334 wxSizerItem *result = 0 ;
48335 void *argp1 = 0 ;
48336 int res1 = 0 ;
48337 int res2 = 0 ;
48338 PyObject * obj0 = 0 ;
48339 PyObject * obj1 = 0 ;
48340 char * kwnames[] = {
48341 (char *) "self",(char *) "item", NULL
48342 };
48343
48344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48346 if (!SWIG_IsOK(res1)) {
48347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48348 }
48349 arg1 = reinterpret_cast< wxSizer * >(argp1);
48350 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48351 if (!SWIG_IsOK(res2)) {
48352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48353 }
48354 {
48355 PyThreadState* __tstate = wxPyBeginAllowThreads();
48356 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48357 wxPyEndAllowThreads(__tstate);
48358 if (PyErr_Occurred()) SWIG_fail;
48359 }
48360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48361 return resultobj;
48362 fail:
48363 return NULL;
48364 }
48365
48366
48367 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48368 PyObject *resultobj = 0;
48369 wxSizer *arg1 = (wxSizer *) 0 ;
48370 int arg2 ;
48371 int arg3 ;
48372 int arg4 ;
48373 int arg5 ;
48374 void *argp1 = 0 ;
48375 int res1 = 0 ;
48376 int val2 ;
48377 int ecode2 = 0 ;
48378 int val3 ;
48379 int ecode3 = 0 ;
48380 int val4 ;
48381 int ecode4 = 0 ;
48382 int val5 ;
48383 int ecode5 = 0 ;
48384 PyObject * obj0 = 0 ;
48385 PyObject * obj1 = 0 ;
48386 PyObject * obj2 = 0 ;
48387 PyObject * obj3 = 0 ;
48388 PyObject * obj4 = 0 ;
48389 char * kwnames[] = {
48390 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48391 };
48392
48393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48395 if (!SWIG_IsOK(res1)) {
48396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48397 }
48398 arg1 = reinterpret_cast< wxSizer * >(argp1);
48399 ecode2 = SWIG_AsVal_int(obj1, &val2);
48400 if (!SWIG_IsOK(ecode2)) {
48401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48402 }
48403 arg2 = static_cast< int >(val2);
48404 ecode3 = SWIG_AsVal_int(obj2, &val3);
48405 if (!SWIG_IsOK(ecode3)) {
48406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48407 }
48408 arg3 = static_cast< int >(val3);
48409 ecode4 = SWIG_AsVal_int(obj3, &val4);
48410 if (!SWIG_IsOK(ecode4)) {
48411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48412 }
48413 arg4 = static_cast< int >(val4);
48414 ecode5 = SWIG_AsVal_int(obj4, &val5);
48415 if (!SWIG_IsOK(ecode5)) {
48416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48417 }
48418 arg5 = static_cast< int >(val5);
48419 {
48420 PyThreadState* __tstate = wxPyBeginAllowThreads();
48421 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48422 wxPyEndAllowThreads(__tstate);
48423 if (PyErr_Occurred()) SWIG_fail;
48424 }
48425 resultobj = SWIG_Py_Void();
48426 return resultobj;
48427 fail:
48428 return NULL;
48429 }
48430
48431
48432 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48433 PyObject *resultobj = 0;
48434 wxSizer *arg1 = (wxSizer *) 0 ;
48435 wxSize *arg2 = 0 ;
48436 void *argp1 = 0 ;
48437 int res1 = 0 ;
48438 wxSize temp2 ;
48439 PyObject * obj0 = 0 ;
48440 PyObject * obj1 = 0 ;
48441 char * kwnames[] = {
48442 (char *) "self",(char *) "size", NULL
48443 };
48444
48445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48447 if (!SWIG_IsOK(res1)) {
48448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48449 }
48450 arg1 = reinterpret_cast< wxSizer * >(argp1);
48451 {
48452 arg2 = &temp2;
48453 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48454 }
48455 {
48456 PyThreadState* __tstate = wxPyBeginAllowThreads();
48457 (arg1)->SetMinSize((wxSize const &)*arg2);
48458 wxPyEndAllowThreads(__tstate);
48459 if (PyErr_Occurred()) SWIG_fail;
48460 }
48461 resultobj = SWIG_Py_Void();
48462 return resultobj;
48463 fail:
48464 return NULL;
48465 }
48466
48467
48468 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48469 PyObject *resultobj = 0;
48470 wxSizer *arg1 = (wxSizer *) 0 ;
48471 wxSize result;
48472 void *argp1 = 0 ;
48473 int res1 = 0 ;
48474 PyObject *swig_obj[1] ;
48475
48476 if (!args) SWIG_fail;
48477 swig_obj[0] = args;
48478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48479 if (!SWIG_IsOK(res1)) {
48480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48481 }
48482 arg1 = reinterpret_cast< wxSizer * >(argp1);
48483 {
48484 PyThreadState* __tstate = wxPyBeginAllowThreads();
48485 result = (arg1)->GetSize();
48486 wxPyEndAllowThreads(__tstate);
48487 if (PyErr_Occurred()) SWIG_fail;
48488 }
48489 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48490 return resultobj;
48491 fail:
48492 return NULL;
48493 }
48494
48495
48496 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48497 PyObject *resultobj = 0;
48498 wxSizer *arg1 = (wxSizer *) 0 ;
48499 wxPoint result;
48500 void *argp1 = 0 ;
48501 int res1 = 0 ;
48502 PyObject *swig_obj[1] ;
48503
48504 if (!args) SWIG_fail;
48505 swig_obj[0] = args;
48506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48507 if (!SWIG_IsOK(res1)) {
48508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48509 }
48510 arg1 = reinterpret_cast< wxSizer * >(argp1);
48511 {
48512 PyThreadState* __tstate = wxPyBeginAllowThreads();
48513 result = (arg1)->GetPosition();
48514 wxPyEndAllowThreads(__tstate);
48515 if (PyErr_Occurred()) SWIG_fail;
48516 }
48517 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48518 return resultobj;
48519 fail:
48520 return NULL;
48521 }
48522
48523
48524 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48525 PyObject *resultobj = 0;
48526 wxSizer *arg1 = (wxSizer *) 0 ;
48527 wxSize result;
48528 void *argp1 = 0 ;
48529 int res1 = 0 ;
48530 PyObject *swig_obj[1] ;
48531
48532 if (!args) SWIG_fail;
48533 swig_obj[0] = args;
48534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48535 if (!SWIG_IsOK(res1)) {
48536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48537 }
48538 arg1 = reinterpret_cast< wxSizer * >(argp1);
48539 {
48540 PyThreadState* __tstate = wxPyBeginAllowThreads();
48541 result = (arg1)->GetMinSize();
48542 wxPyEndAllowThreads(__tstate);
48543 if (PyErr_Occurred()) SWIG_fail;
48544 }
48545 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48546 return resultobj;
48547 fail:
48548 return NULL;
48549 }
48550
48551
48552 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48553 PyObject *resultobj = 0;
48554 wxSizer *arg1 = (wxSizer *) 0 ;
48555 void *argp1 = 0 ;
48556 int res1 = 0 ;
48557 PyObject *swig_obj[1] ;
48558
48559 if (!args) SWIG_fail;
48560 swig_obj[0] = args;
48561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48562 if (!SWIG_IsOK(res1)) {
48563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48564 }
48565 arg1 = reinterpret_cast< wxSizer * >(argp1);
48566 {
48567 PyThreadState* __tstate = wxPyBeginAllowThreads();
48568 (arg1)->RecalcSizes();
48569 wxPyEndAllowThreads(__tstate);
48570 if (PyErr_Occurred()) SWIG_fail;
48571 }
48572 resultobj = SWIG_Py_Void();
48573 return resultobj;
48574 fail:
48575 return NULL;
48576 }
48577
48578
48579 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48580 PyObject *resultobj = 0;
48581 wxSizer *arg1 = (wxSizer *) 0 ;
48582 wxSize result;
48583 void *argp1 = 0 ;
48584 int res1 = 0 ;
48585 PyObject *swig_obj[1] ;
48586
48587 if (!args) SWIG_fail;
48588 swig_obj[0] = args;
48589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48590 if (!SWIG_IsOK(res1)) {
48591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48592 }
48593 arg1 = reinterpret_cast< wxSizer * >(argp1);
48594 {
48595 PyThreadState* __tstate = wxPyBeginAllowThreads();
48596 result = (arg1)->CalcMin();
48597 wxPyEndAllowThreads(__tstate);
48598 if (PyErr_Occurred()) SWIG_fail;
48599 }
48600 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48601 return resultobj;
48602 fail:
48603 return NULL;
48604 }
48605
48606
48607 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48608 PyObject *resultobj = 0;
48609 wxSizer *arg1 = (wxSizer *) 0 ;
48610 void *argp1 = 0 ;
48611 int res1 = 0 ;
48612 PyObject *swig_obj[1] ;
48613
48614 if (!args) SWIG_fail;
48615 swig_obj[0] = args;
48616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48617 if (!SWIG_IsOK(res1)) {
48618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48619 }
48620 arg1 = reinterpret_cast< wxSizer * >(argp1);
48621 {
48622 PyThreadState* __tstate = wxPyBeginAllowThreads();
48623 (arg1)->Layout();
48624 wxPyEndAllowThreads(__tstate);
48625 if (PyErr_Occurred()) SWIG_fail;
48626 }
48627 resultobj = SWIG_Py_Void();
48628 return resultobj;
48629 fail:
48630 return NULL;
48631 }
48632
48633
48634 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48635 PyObject *resultobj = 0;
48636 wxSizer *arg1 = (wxSizer *) 0 ;
48637 wxWindow *arg2 = (wxWindow *) 0 ;
48638 wxSize result;
48639 void *argp1 = 0 ;
48640 int res1 = 0 ;
48641 void *argp2 = 0 ;
48642 int res2 = 0 ;
48643 PyObject * obj0 = 0 ;
48644 PyObject * obj1 = 0 ;
48645 char * kwnames[] = {
48646 (char *) "self",(char *) "window", NULL
48647 };
48648
48649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48651 if (!SWIG_IsOK(res1)) {
48652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48653 }
48654 arg1 = reinterpret_cast< wxSizer * >(argp1);
48655 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48656 if (!SWIG_IsOK(res2)) {
48657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48658 }
48659 arg2 = reinterpret_cast< wxWindow * >(argp2);
48660 {
48661 PyThreadState* __tstate = wxPyBeginAllowThreads();
48662 result = (arg1)->Fit(arg2);
48663 wxPyEndAllowThreads(__tstate);
48664 if (PyErr_Occurred()) SWIG_fail;
48665 }
48666 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48667 return resultobj;
48668 fail:
48669 return NULL;
48670 }
48671
48672
48673 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48674 PyObject *resultobj = 0;
48675 wxSizer *arg1 = (wxSizer *) 0 ;
48676 wxWindow *arg2 = (wxWindow *) 0 ;
48677 void *argp1 = 0 ;
48678 int res1 = 0 ;
48679 void *argp2 = 0 ;
48680 int res2 = 0 ;
48681 PyObject * obj0 = 0 ;
48682 PyObject * obj1 = 0 ;
48683 char * kwnames[] = {
48684 (char *) "self",(char *) "window", NULL
48685 };
48686
48687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48689 if (!SWIG_IsOK(res1)) {
48690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48691 }
48692 arg1 = reinterpret_cast< wxSizer * >(argp1);
48693 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48694 if (!SWIG_IsOK(res2)) {
48695 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48696 }
48697 arg2 = reinterpret_cast< wxWindow * >(argp2);
48698 {
48699 PyThreadState* __tstate = wxPyBeginAllowThreads();
48700 (arg1)->FitInside(arg2);
48701 wxPyEndAllowThreads(__tstate);
48702 if (PyErr_Occurred()) SWIG_fail;
48703 }
48704 resultobj = SWIG_Py_Void();
48705 return resultobj;
48706 fail:
48707 return NULL;
48708 }
48709
48710
48711 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48712 PyObject *resultobj = 0;
48713 wxSizer *arg1 = (wxSizer *) 0 ;
48714 wxWindow *arg2 = (wxWindow *) 0 ;
48715 void *argp1 = 0 ;
48716 int res1 = 0 ;
48717 void *argp2 = 0 ;
48718 int res2 = 0 ;
48719 PyObject * obj0 = 0 ;
48720 PyObject * obj1 = 0 ;
48721 char * kwnames[] = {
48722 (char *) "self",(char *) "window", NULL
48723 };
48724
48725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48727 if (!SWIG_IsOK(res1)) {
48728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48729 }
48730 arg1 = reinterpret_cast< wxSizer * >(argp1);
48731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48732 if (!SWIG_IsOK(res2)) {
48733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48734 }
48735 arg2 = reinterpret_cast< wxWindow * >(argp2);
48736 {
48737 PyThreadState* __tstate = wxPyBeginAllowThreads();
48738 (arg1)->SetSizeHints(arg2);
48739 wxPyEndAllowThreads(__tstate);
48740 if (PyErr_Occurred()) SWIG_fail;
48741 }
48742 resultobj = SWIG_Py_Void();
48743 return resultobj;
48744 fail:
48745 return NULL;
48746 }
48747
48748
48749 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48750 PyObject *resultobj = 0;
48751 wxSizer *arg1 = (wxSizer *) 0 ;
48752 wxWindow *arg2 = (wxWindow *) 0 ;
48753 void *argp1 = 0 ;
48754 int res1 = 0 ;
48755 void *argp2 = 0 ;
48756 int res2 = 0 ;
48757 PyObject * obj0 = 0 ;
48758 PyObject * obj1 = 0 ;
48759 char * kwnames[] = {
48760 (char *) "self",(char *) "window", NULL
48761 };
48762
48763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48765 if (!SWIG_IsOK(res1)) {
48766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48767 }
48768 arg1 = reinterpret_cast< wxSizer * >(argp1);
48769 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48770 if (!SWIG_IsOK(res2)) {
48771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48772 }
48773 arg2 = reinterpret_cast< wxWindow * >(argp2);
48774 {
48775 PyThreadState* __tstate = wxPyBeginAllowThreads();
48776 (arg1)->SetVirtualSizeHints(arg2);
48777 wxPyEndAllowThreads(__tstate);
48778 if (PyErr_Occurred()) SWIG_fail;
48779 }
48780 resultobj = SWIG_Py_Void();
48781 return resultobj;
48782 fail:
48783 return NULL;
48784 }
48785
48786
48787 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48788 PyObject *resultobj = 0;
48789 wxSizer *arg1 = (wxSizer *) 0 ;
48790 bool arg2 = (bool) false ;
48791 void *argp1 = 0 ;
48792 int res1 = 0 ;
48793 bool val2 ;
48794 int ecode2 = 0 ;
48795 PyObject * obj0 = 0 ;
48796 PyObject * obj1 = 0 ;
48797 char * kwnames[] = {
48798 (char *) "self",(char *) "deleteWindows", NULL
48799 };
48800
48801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48803 if (!SWIG_IsOK(res1)) {
48804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48805 }
48806 arg1 = reinterpret_cast< wxSizer * >(argp1);
48807 if (obj1) {
48808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48809 if (!SWIG_IsOK(ecode2)) {
48810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48811 }
48812 arg2 = static_cast< bool >(val2);
48813 }
48814 {
48815 PyThreadState* __tstate = wxPyBeginAllowThreads();
48816 (arg1)->Clear(arg2);
48817 wxPyEndAllowThreads(__tstate);
48818 if (PyErr_Occurred()) SWIG_fail;
48819 }
48820 resultobj = SWIG_Py_Void();
48821 return resultobj;
48822 fail:
48823 return NULL;
48824 }
48825
48826
48827 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48828 PyObject *resultobj = 0;
48829 wxSizer *arg1 = (wxSizer *) 0 ;
48830 void *argp1 = 0 ;
48831 int res1 = 0 ;
48832 PyObject *swig_obj[1] ;
48833
48834 if (!args) SWIG_fail;
48835 swig_obj[0] = args;
48836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48837 if (!SWIG_IsOK(res1)) {
48838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48839 }
48840 arg1 = reinterpret_cast< wxSizer * >(argp1);
48841 {
48842 PyThreadState* __tstate = wxPyBeginAllowThreads();
48843 (arg1)->DeleteWindows();
48844 wxPyEndAllowThreads(__tstate);
48845 if (PyErr_Occurred()) SWIG_fail;
48846 }
48847 resultobj = SWIG_Py_Void();
48848 return resultobj;
48849 fail:
48850 return NULL;
48851 }
48852
48853
48854 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48855 PyObject *resultobj = 0;
48856 wxSizer *arg1 = (wxSizer *) 0 ;
48857 PyObject *result = 0 ;
48858 void *argp1 = 0 ;
48859 int res1 = 0 ;
48860 PyObject *swig_obj[1] ;
48861
48862 if (!args) SWIG_fail;
48863 swig_obj[0] = args;
48864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48865 if (!SWIG_IsOK(res1)) {
48866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48867 }
48868 arg1 = reinterpret_cast< wxSizer * >(argp1);
48869 {
48870 PyThreadState* __tstate = wxPyBeginAllowThreads();
48871 result = (PyObject *)wxSizer_GetChildren(arg1);
48872 wxPyEndAllowThreads(__tstate);
48873 if (PyErr_Occurred()) SWIG_fail;
48874 }
48875 resultobj = result;
48876 return resultobj;
48877 fail:
48878 return NULL;
48879 }
48880
48881
48882 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48883 PyObject *resultobj = 0;
48884 wxSizer *arg1 = (wxSizer *) 0 ;
48885 PyObject *arg2 = (PyObject *) 0 ;
48886 bool arg3 = (bool) true ;
48887 bool arg4 = (bool) false ;
48888 bool result;
48889 void *argp1 = 0 ;
48890 int res1 = 0 ;
48891 bool val3 ;
48892 int ecode3 = 0 ;
48893 bool val4 ;
48894 int ecode4 = 0 ;
48895 PyObject * obj0 = 0 ;
48896 PyObject * obj1 = 0 ;
48897 PyObject * obj2 = 0 ;
48898 PyObject * obj3 = 0 ;
48899 char * kwnames[] = {
48900 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48901 };
48902
48903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48905 if (!SWIG_IsOK(res1)) {
48906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48907 }
48908 arg1 = reinterpret_cast< wxSizer * >(argp1);
48909 arg2 = obj1;
48910 if (obj2) {
48911 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48912 if (!SWIG_IsOK(ecode3)) {
48913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48914 }
48915 arg3 = static_cast< bool >(val3);
48916 }
48917 if (obj3) {
48918 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48919 if (!SWIG_IsOK(ecode4)) {
48920 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48921 }
48922 arg4 = static_cast< bool >(val4);
48923 }
48924 {
48925 PyThreadState* __tstate = wxPyBeginAllowThreads();
48926 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48927 wxPyEndAllowThreads(__tstate);
48928 if (PyErr_Occurred()) SWIG_fail;
48929 }
48930 {
48931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48932 }
48933 return resultobj;
48934 fail:
48935 return NULL;
48936 }
48937
48938
48939 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48940 PyObject *resultobj = 0;
48941 wxSizer *arg1 = (wxSizer *) 0 ;
48942 PyObject *arg2 = (PyObject *) 0 ;
48943 bool result;
48944 void *argp1 = 0 ;
48945 int res1 = 0 ;
48946 PyObject * obj0 = 0 ;
48947 PyObject * obj1 = 0 ;
48948 char * kwnames[] = {
48949 (char *) "self",(char *) "item", NULL
48950 };
48951
48952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48954 if (!SWIG_IsOK(res1)) {
48955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48956 }
48957 arg1 = reinterpret_cast< wxSizer * >(argp1);
48958 arg2 = obj1;
48959 {
48960 PyThreadState* __tstate = wxPyBeginAllowThreads();
48961 result = (bool)wxSizer_IsShown(arg1,arg2);
48962 wxPyEndAllowThreads(__tstate);
48963 if (PyErr_Occurred()) SWIG_fail;
48964 }
48965 {
48966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48967 }
48968 return resultobj;
48969 fail:
48970 return NULL;
48971 }
48972
48973
48974 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48975 PyObject *resultobj = 0;
48976 wxSizer *arg1 = (wxSizer *) 0 ;
48977 bool arg2 ;
48978 void *argp1 = 0 ;
48979 int res1 = 0 ;
48980 bool val2 ;
48981 int ecode2 = 0 ;
48982 PyObject * obj0 = 0 ;
48983 PyObject * obj1 = 0 ;
48984 char * kwnames[] = {
48985 (char *) "self",(char *) "show", NULL
48986 };
48987
48988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48990 if (!SWIG_IsOK(res1)) {
48991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48992 }
48993 arg1 = reinterpret_cast< wxSizer * >(argp1);
48994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48995 if (!SWIG_IsOK(ecode2)) {
48996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48997 }
48998 arg2 = static_cast< bool >(val2);
48999 {
49000 PyThreadState* __tstate = wxPyBeginAllowThreads();
49001 (arg1)->ShowItems(arg2);
49002 wxPyEndAllowThreads(__tstate);
49003 if (PyErr_Occurred()) SWIG_fail;
49004 }
49005 resultobj = SWIG_Py_Void();
49006 return resultobj;
49007 fail:
49008 return NULL;
49009 }
49010
49011
49012 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49013 PyObject *obj;
49014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49015 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49016 return SWIG_Py_Void();
49017 }
49018
49019 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49020 PyObject *resultobj = 0;
49021 wxPySizer *result = 0 ;
49022
49023 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49024 {
49025 PyThreadState* __tstate = wxPyBeginAllowThreads();
49026 result = (wxPySizer *)new wxPySizer();
49027 wxPyEndAllowThreads(__tstate);
49028 if (PyErr_Occurred()) SWIG_fail;
49029 }
49030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49031 return resultobj;
49032 fail:
49033 return NULL;
49034 }
49035
49036
49037 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49038 PyObject *resultobj = 0;
49039 wxPySizer *arg1 = (wxPySizer *) 0 ;
49040 PyObject *arg2 = (PyObject *) 0 ;
49041 PyObject *arg3 = (PyObject *) 0 ;
49042 void *argp1 = 0 ;
49043 int res1 = 0 ;
49044 PyObject * obj0 = 0 ;
49045 PyObject * obj1 = 0 ;
49046 PyObject * obj2 = 0 ;
49047 char * kwnames[] = {
49048 (char *) "self",(char *) "self",(char *) "_class", NULL
49049 };
49050
49051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49053 if (!SWIG_IsOK(res1)) {
49054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49055 }
49056 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49057 arg2 = obj1;
49058 arg3 = obj2;
49059 {
49060 PyThreadState* __tstate = wxPyBeginAllowThreads();
49061 (arg1)->_setCallbackInfo(arg2,arg3);
49062 wxPyEndAllowThreads(__tstate);
49063 if (PyErr_Occurred()) SWIG_fail;
49064 }
49065 resultobj = SWIG_Py_Void();
49066 return resultobj;
49067 fail:
49068 return NULL;
49069 }
49070
49071
49072 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49073 PyObject *obj;
49074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49075 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49076 return SWIG_Py_Void();
49077 }
49078
49079 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49080 return SWIG_Python_InitShadowInstance(args);
49081 }
49082
49083 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49084 PyObject *resultobj = 0;
49085 int arg1 = (int) wxHORIZONTAL ;
49086 wxBoxSizer *result = 0 ;
49087 int val1 ;
49088 int ecode1 = 0 ;
49089 PyObject * obj0 = 0 ;
49090 char * kwnames[] = {
49091 (char *) "orient", NULL
49092 };
49093
49094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49095 if (obj0) {
49096 ecode1 = SWIG_AsVal_int(obj0, &val1);
49097 if (!SWIG_IsOK(ecode1)) {
49098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49099 }
49100 arg1 = static_cast< int >(val1);
49101 }
49102 {
49103 PyThreadState* __tstate = wxPyBeginAllowThreads();
49104 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49105 wxPyEndAllowThreads(__tstate);
49106 if (PyErr_Occurred()) SWIG_fail;
49107 }
49108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49109 return resultobj;
49110 fail:
49111 return NULL;
49112 }
49113
49114
49115 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49116 PyObject *resultobj = 0;
49117 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49118 int result;
49119 void *argp1 = 0 ;
49120 int res1 = 0 ;
49121 PyObject *swig_obj[1] ;
49122
49123 if (!args) SWIG_fail;
49124 swig_obj[0] = args;
49125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49126 if (!SWIG_IsOK(res1)) {
49127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49128 }
49129 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49130 {
49131 PyThreadState* __tstate = wxPyBeginAllowThreads();
49132 result = (int)(arg1)->GetOrientation();
49133 wxPyEndAllowThreads(__tstate);
49134 if (PyErr_Occurred()) SWIG_fail;
49135 }
49136 resultobj = SWIG_From_int(static_cast< int >(result));
49137 return resultobj;
49138 fail:
49139 return NULL;
49140 }
49141
49142
49143 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49144 PyObject *resultobj = 0;
49145 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49146 int arg2 ;
49147 void *argp1 = 0 ;
49148 int res1 = 0 ;
49149 int val2 ;
49150 int ecode2 = 0 ;
49151 PyObject * obj0 = 0 ;
49152 PyObject * obj1 = 0 ;
49153 char * kwnames[] = {
49154 (char *) "self",(char *) "orient", NULL
49155 };
49156
49157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49159 if (!SWIG_IsOK(res1)) {
49160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49161 }
49162 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49163 ecode2 = SWIG_AsVal_int(obj1, &val2);
49164 if (!SWIG_IsOK(ecode2)) {
49165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49166 }
49167 arg2 = static_cast< int >(val2);
49168 {
49169 PyThreadState* __tstate = wxPyBeginAllowThreads();
49170 (arg1)->SetOrientation(arg2);
49171 wxPyEndAllowThreads(__tstate);
49172 if (PyErr_Occurred()) SWIG_fail;
49173 }
49174 resultobj = SWIG_Py_Void();
49175 return resultobj;
49176 fail:
49177 return NULL;
49178 }
49179
49180
49181 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49182 PyObject *obj;
49183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49184 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49185 return SWIG_Py_Void();
49186 }
49187
49188 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49189 return SWIG_Python_InitShadowInstance(args);
49190 }
49191
49192 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49193 PyObject *resultobj = 0;
49194 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49195 int arg2 = (int) wxHORIZONTAL ;
49196 wxStaticBoxSizer *result = 0 ;
49197 void *argp1 = 0 ;
49198 int res1 = 0 ;
49199 int val2 ;
49200 int ecode2 = 0 ;
49201 PyObject * obj0 = 0 ;
49202 PyObject * obj1 = 0 ;
49203 char * kwnames[] = {
49204 (char *) "box",(char *) "orient", NULL
49205 };
49206
49207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49209 if (!SWIG_IsOK(res1)) {
49210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49211 }
49212 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49213 if (obj1) {
49214 ecode2 = SWIG_AsVal_int(obj1, &val2);
49215 if (!SWIG_IsOK(ecode2)) {
49216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49217 }
49218 arg2 = static_cast< int >(val2);
49219 }
49220 {
49221 PyThreadState* __tstate = wxPyBeginAllowThreads();
49222 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49223 wxPyEndAllowThreads(__tstate);
49224 if (PyErr_Occurred()) SWIG_fail;
49225 }
49226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49227 return resultobj;
49228 fail:
49229 return NULL;
49230 }
49231
49232
49233 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49234 PyObject *resultobj = 0;
49235 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49236 wxStaticBox *result = 0 ;
49237 void *argp1 = 0 ;
49238 int res1 = 0 ;
49239 PyObject *swig_obj[1] ;
49240
49241 if (!args) SWIG_fail;
49242 swig_obj[0] = args;
49243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49244 if (!SWIG_IsOK(res1)) {
49245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49246 }
49247 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49248 {
49249 PyThreadState* __tstate = wxPyBeginAllowThreads();
49250 result = (wxStaticBox *)(arg1)->GetStaticBox();
49251 wxPyEndAllowThreads(__tstate);
49252 if (PyErr_Occurred()) SWIG_fail;
49253 }
49254 {
49255 resultobj = wxPyMake_wxObject(result, (bool)0);
49256 }
49257 return resultobj;
49258 fail:
49259 return NULL;
49260 }
49261
49262
49263 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49264 PyObject *obj;
49265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49266 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49267 return SWIG_Py_Void();
49268 }
49269
49270 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49271 return SWIG_Python_InitShadowInstance(args);
49272 }
49273
49274 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49275 PyObject *resultobj = 0;
49276 int arg1 = (int) 1 ;
49277 int arg2 = (int) 0 ;
49278 int arg3 = (int) 0 ;
49279 int arg4 = (int) 0 ;
49280 wxGridSizer *result = 0 ;
49281 int val1 ;
49282 int ecode1 = 0 ;
49283 int val2 ;
49284 int ecode2 = 0 ;
49285 int val3 ;
49286 int ecode3 = 0 ;
49287 int val4 ;
49288 int ecode4 = 0 ;
49289 PyObject * obj0 = 0 ;
49290 PyObject * obj1 = 0 ;
49291 PyObject * obj2 = 0 ;
49292 PyObject * obj3 = 0 ;
49293 char * kwnames[] = {
49294 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49295 };
49296
49297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49298 if (obj0) {
49299 ecode1 = SWIG_AsVal_int(obj0, &val1);
49300 if (!SWIG_IsOK(ecode1)) {
49301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49302 }
49303 arg1 = static_cast< int >(val1);
49304 }
49305 if (obj1) {
49306 ecode2 = SWIG_AsVal_int(obj1, &val2);
49307 if (!SWIG_IsOK(ecode2)) {
49308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49309 }
49310 arg2 = static_cast< int >(val2);
49311 }
49312 if (obj2) {
49313 ecode3 = SWIG_AsVal_int(obj2, &val3);
49314 if (!SWIG_IsOK(ecode3)) {
49315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49316 }
49317 arg3 = static_cast< int >(val3);
49318 }
49319 if (obj3) {
49320 ecode4 = SWIG_AsVal_int(obj3, &val4);
49321 if (!SWIG_IsOK(ecode4)) {
49322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49323 }
49324 arg4 = static_cast< int >(val4);
49325 }
49326 {
49327 PyThreadState* __tstate = wxPyBeginAllowThreads();
49328 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49329 wxPyEndAllowThreads(__tstate);
49330 if (PyErr_Occurred()) SWIG_fail;
49331 }
49332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49333 return resultobj;
49334 fail:
49335 return NULL;
49336 }
49337
49338
49339 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49340 PyObject *resultobj = 0;
49341 wxGridSizer *arg1 = (wxGridSizer *) 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 *) "cols", NULL
49351 };
49352
49353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49355 if (!SWIG_IsOK(res1)) {
49356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49357 }
49358 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49359 ecode2 = SWIG_AsVal_int(obj1, &val2);
49360 if (!SWIG_IsOK(ecode2)) {
49361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49362 }
49363 arg2 = static_cast< int >(val2);
49364 {
49365 PyThreadState* __tstate = wxPyBeginAllowThreads();
49366 (arg1)->SetCols(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_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49378 PyObject *resultobj = 0;
49379 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49380 int arg2 ;
49381 void *argp1 = 0 ;
49382 int res1 = 0 ;
49383 int val2 ;
49384 int ecode2 = 0 ;
49385 PyObject * obj0 = 0 ;
49386 PyObject * obj1 = 0 ;
49387 char * kwnames[] = {
49388 (char *) "self",(char *) "rows", NULL
49389 };
49390
49391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49393 if (!SWIG_IsOK(res1)) {
49394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49395 }
49396 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49397 ecode2 = SWIG_AsVal_int(obj1, &val2);
49398 if (!SWIG_IsOK(ecode2)) {
49399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49400 }
49401 arg2 = static_cast< int >(val2);
49402 {
49403 PyThreadState* __tstate = wxPyBeginAllowThreads();
49404 (arg1)->SetRows(arg2);
49405 wxPyEndAllowThreads(__tstate);
49406 if (PyErr_Occurred()) SWIG_fail;
49407 }
49408 resultobj = SWIG_Py_Void();
49409 return resultobj;
49410 fail:
49411 return NULL;
49412 }
49413
49414
49415 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49416 PyObject *resultobj = 0;
49417 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49418 int arg2 ;
49419 void *argp1 = 0 ;
49420 int res1 = 0 ;
49421 int val2 ;
49422 int ecode2 = 0 ;
49423 PyObject * obj0 = 0 ;
49424 PyObject * obj1 = 0 ;
49425 char * kwnames[] = {
49426 (char *) "self",(char *) "gap", NULL
49427 };
49428
49429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49431 if (!SWIG_IsOK(res1)) {
49432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49433 }
49434 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49435 ecode2 = SWIG_AsVal_int(obj1, &val2);
49436 if (!SWIG_IsOK(ecode2)) {
49437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49438 }
49439 arg2 = static_cast< int >(val2);
49440 {
49441 PyThreadState* __tstate = wxPyBeginAllowThreads();
49442 (arg1)->SetVGap(arg2);
49443 wxPyEndAllowThreads(__tstate);
49444 if (PyErr_Occurred()) SWIG_fail;
49445 }
49446 resultobj = SWIG_Py_Void();
49447 return resultobj;
49448 fail:
49449 return NULL;
49450 }
49451
49452
49453 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49454 PyObject *resultobj = 0;
49455 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49456 int arg2 ;
49457 void *argp1 = 0 ;
49458 int res1 = 0 ;
49459 int val2 ;
49460 int ecode2 = 0 ;
49461 PyObject * obj0 = 0 ;
49462 PyObject * obj1 = 0 ;
49463 char * kwnames[] = {
49464 (char *) "self",(char *) "gap", NULL
49465 };
49466
49467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49469 if (!SWIG_IsOK(res1)) {
49470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49471 }
49472 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49473 ecode2 = SWIG_AsVal_int(obj1, &val2);
49474 if (!SWIG_IsOK(ecode2)) {
49475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49476 }
49477 arg2 = static_cast< int >(val2);
49478 {
49479 PyThreadState* __tstate = wxPyBeginAllowThreads();
49480 (arg1)->SetHGap(arg2);
49481 wxPyEndAllowThreads(__tstate);
49482 if (PyErr_Occurred()) SWIG_fail;
49483 }
49484 resultobj = SWIG_Py_Void();
49485 return resultobj;
49486 fail:
49487 return NULL;
49488 }
49489
49490
49491 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49492 PyObject *resultobj = 0;
49493 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49494 int result;
49495 void *argp1 = 0 ;
49496 int res1 = 0 ;
49497 PyObject *swig_obj[1] ;
49498
49499 if (!args) SWIG_fail;
49500 swig_obj[0] = args;
49501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49502 if (!SWIG_IsOK(res1)) {
49503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49504 }
49505 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49506 {
49507 PyThreadState* __tstate = wxPyBeginAllowThreads();
49508 result = (int)(arg1)->GetCols();
49509 wxPyEndAllowThreads(__tstate);
49510 if (PyErr_Occurred()) SWIG_fail;
49511 }
49512 resultobj = SWIG_From_int(static_cast< int >(result));
49513 return resultobj;
49514 fail:
49515 return NULL;
49516 }
49517
49518
49519 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49520 PyObject *resultobj = 0;
49521 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49522 int result;
49523 void *argp1 = 0 ;
49524 int res1 = 0 ;
49525 PyObject *swig_obj[1] ;
49526
49527 if (!args) SWIG_fail;
49528 swig_obj[0] = args;
49529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49530 if (!SWIG_IsOK(res1)) {
49531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49532 }
49533 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49534 {
49535 PyThreadState* __tstate = wxPyBeginAllowThreads();
49536 result = (int)(arg1)->GetRows();
49537 wxPyEndAllowThreads(__tstate);
49538 if (PyErr_Occurred()) SWIG_fail;
49539 }
49540 resultobj = SWIG_From_int(static_cast< int >(result));
49541 return resultobj;
49542 fail:
49543 return NULL;
49544 }
49545
49546
49547 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49548 PyObject *resultobj = 0;
49549 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49550 int result;
49551 void *argp1 = 0 ;
49552 int res1 = 0 ;
49553 PyObject *swig_obj[1] ;
49554
49555 if (!args) SWIG_fail;
49556 swig_obj[0] = args;
49557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49558 if (!SWIG_IsOK(res1)) {
49559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49560 }
49561 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49562 {
49563 PyThreadState* __tstate = wxPyBeginAllowThreads();
49564 result = (int)(arg1)->GetVGap();
49565 wxPyEndAllowThreads(__tstate);
49566 if (PyErr_Occurred()) SWIG_fail;
49567 }
49568 resultobj = SWIG_From_int(static_cast< int >(result));
49569 return resultobj;
49570 fail:
49571 return NULL;
49572 }
49573
49574
49575 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49576 PyObject *resultobj = 0;
49577 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49578 int result;
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_wxGridSizer, 0 | 0 );
49586 if (!SWIG_IsOK(res1)) {
49587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49588 }
49589 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49590 {
49591 PyThreadState* __tstate = wxPyBeginAllowThreads();
49592 result = (int)(arg1)->GetHGap();
49593 wxPyEndAllowThreads(__tstate);
49594 if (PyErr_Occurred()) SWIG_fail;
49595 }
49596 resultobj = SWIG_From_int(static_cast< int >(result));
49597 return resultobj;
49598 fail:
49599 return NULL;
49600 }
49601
49602
49603 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49604 PyObject *obj;
49605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49606 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49607 return SWIG_Py_Void();
49608 }
49609
49610 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49611 return SWIG_Python_InitShadowInstance(args);
49612 }
49613
49614 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49615 PyObject *resultobj = 0;
49616 int arg1 = (int) 1 ;
49617 int arg2 = (int) 0 ;
49618 int arg3 = (int) 0 ;
49619 int arg4 = (int) 0 ;
49620 wxFlexGridSizer *result = 0 ;
49621 int val1 ;
49622 int ecode1 = 0 ;
49623 int val2 ;
49624 int ecode2 = 0 ;
49625 int val3 ;
49626 int ecode3 = 0 ;
49627 int val4 ;
49628 int ecode4 = 0 ;
49629 PyObject * obj0 = 0 ;
49630 PyObject * obj1 = 0 ;
49631 PyObject * obj2 = 0 ;
49632 PyObject * obj3 = 0 ;
49633 char * kwnames[] = {
49634 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49635 };
49636
49637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49638 if (obj0) {
49639 ecode1 = SWIG_AsVal_int(obj0, &val1);
49640 if (!SWIG_IsOK(ecode1)) {
49641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49642 }
49643 arg1 = static_cast< int >(val1);
49644 }
49645 if (obj1) {
49646 ecode2 = SWIG_AsVal_int(obj1, &val2);
49647 if (!SWIG_IsOK(ecode2)) {
49648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49649 }
49650 arg2 = static_cast< int >(val2);
49651 }
49652 if (obj2) {
49653 ecode3 = SWIG_AsVal_int(obj2, &val3);
49654 if (!SWIG_IsOK(ecode3)) {
49655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49656 }
49657 arg3 = static_cast< int >(val3);
49658 }
49659 if (obj3) {
49660 ecode4 = SWIG_AsVal_int(obj3, &val4);
49661 if (!SWIG_IsOK(ecode4)) {
49662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49663 }
49664 arg4 = static_cast< int >(val4);
49665 }
49666 {
49667 PyThreadState* __tstate = wxPyBeginAllowThreads();
49668 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49669 wxPyEndAllowThreads(__tstate);
49670 if (PyErr_Occurred()) SWIG_fail;
49671 }
49672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49673 return resultobj;
49674 fail:
49675 return NULL;
49676 }
49677
49678
49679 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49680 PyObject *resultobj = 0;
49681 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49682 size_t arg2 ;
49683 int arg3 = (int) 0 ;
49684 void *argp1 = 0 ;
49685 int res1 = 0 ;
49686 size_t val2 ;
49687 int ecode2 = 0 ;
49688 int val3 ;
49689 int ecode3 = 0 ;
49690 PyObject * obj0 = 0 ;
49691 PyObject * obj1 = 0 ;
49692 PyObject * obj2 = 0 ;
49693 char * kwnames[] = {
49694 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49695 };
49696
49697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49699 if (!SWIG_IsOK(res1)) {
49700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49701 }
49702 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49703 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49704 if (!SWIG_IsOK(ecode2)) {
49705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49706 }
49707 arg2 = static_cast< size_t >(val2);
49708 if (obj2) {
49709 ecode3 = SWIG_AsVal_int(obj2, &val3);
49710 if (!SWIG_IsOK(ecode3)) {
49711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49712 }
49713 arg3 = static_cast< int >(val3);
49714 }
49715 {
49716 PyThreadState* __tstate = wxPyBeginAllowThreads();
49717 (arg1)->AddGrowableRow(arg2,arg3);
49718 wxPyEndAllowThreads(__tstate);
49719 if (PyErr_Occurred()) SWIG_fail;
49720 }
49721 resultobj = SWIG_Py_Void();
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49729 PyObject *resultobj = 0;
49730 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49731 size_t arg2 ;
49732 void *argp1 = 0 ;
49733 int res1 = 0 ;
49734 size_t val2 ;
49735 int ecode2 = 0 ;
49736 PyObject * obj0 = 0 ;
49737 PyObject * obj1 = 0 ;
49738 char * kwnames[] = {
49739 (char *) "self",(char *) "idx", NULL
49740 };
49741
49742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49744 if (!SWIG_IsOK(res1)) {
49745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49746 }
49747 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49748 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49749 if (!SWIG_IsOK(ecode2)) {
49750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49751 }
49752 arg2 = static_cast< size_t >(val2);
49753 {
49754 PyThreadState* __tstate = wxPyBeginAllowThreads();
49755 (arg1)->RemoveGrowableRow(arg2);
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 resultobj = SWIG_Py_Void();
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49767 PyObject *resultobj = 0;
49768 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49769 size_t arg2 ;
49770 int arg3 = (int) 0 ;
49771 void *argp1 = 0 ;
49772 int res1 = 0 ;
49773 size_t val2 ;
49774 int ecode2 = 0 ;
49775 int val3 ;
49776 int ecode3 = 0 ;
49777 PyObject * obj0 = 0 ;
49778 PyObject * obj1 = 0 ;
49779 PyObject * obj2 = 0 ;
49780 char * kwnames[] = {
49781 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49782 };
49783
49784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49786 if (!SWIG_IsOK(res1)) {
49787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49788 }
49789 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49790 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49791 if (!SWIG_IsOK(ecode2)) {
49792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49793 }
49794 arg2 = static_cast< size_t >(val2);
49795 if (obj2) {
49796 ecode3 = SWIG_AsVal_int(obj2, &val3);
49797 if (!SWIG_IsOK(ecode3)) {
49798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49799 }
49800 arg3 = static_cast< int >(val3);
49801 }
49802 {
49803 PyThreadState* __tstate = wxPyBeginAllowThreads();
49804 (arg1)->AddGrowableCol(arg2,arg3);
49805 wxPyEndAllowThreads(__tstate);
49806 if (PyErr_Occurred()) SWIG_fail;
49807 }
49808 resultobj = SWIG_Py_Void();
49809 return resultobj;
49810 fail:
49811 return NULL;
49812 }
49813
49814
49815 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49816 PyObject *resultobj = 0;
49817 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49818 size_t arg2 ;
49819 void *argp1 = 0 ;
49820 int res1 = 0 ;
49821 size_t val2 ;
49822 int ecode2 = 0 ;
49823 PyObject * obj0 = 0 ;
49824 PyObject * obj1 = 0 ;
49825 char * kwnames[] = {
49826 (char *) "self",(char *) "idx", NULL
49827 };
49828
49829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49831 if (!SWIG_IsOK(res1)) {
49832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49833 }
49834 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49835 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49836 if (!SWIG_IsOK(ecode2)) {
49837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49838 }
49839 arg2 = static_cast< size_t >(val2);
49840 {
49841 PyThreadState* __tstate = wxPyBeginAllowThreads();
49842 (arg1)->RemoveGrowableCol(arg2);
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_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49854 PyObject *resultobj = 0;
49855 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49856 int arg2 ;
49857 void *argp1 = 0 ;
49858 int res1 = 0 ;
49859 int val2 ;
49860 int ecode2 = 0 ;
49861 PyObject * obj0 = 0 ;
49862 PyObject * obj1 = 0 ;
49863 char * kwnames[] = {
49864 (char *) "self",(char *) "direction", NULL
49865 };
49866
49867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49869 if (!SWIG_IsOK(res1)) {
49870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49871 }
49872 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49873 ecode2 = SWIG_AsVal_int(obj1, &val2);
49874 if (!SWIG_IsOK(ecode2)) {
49875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49876 }
49877 arg2 = static_cast< int >(val2);
49878 {
49879 PyThreadState* __tstate = wxPyBeginAllowThreads();
49880 (arg1)->SetFlexibleDirection(arg2);
49881 wxPyEndAllowThreads(__tstate);
49882 if (PyErr_Occurred()) SWIG_fail;
49883 }
49884 resultobj = SWIG_Py_Void();
49885 return resultobj;
49886 fail:
49887 return NULL;
49888 }
49889
49890
49891 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49892 PyObject *resultobj = 0;
49893 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49894 int result;
49895 void *argp1 = 0 ;
49896 int res1 = 0 ;
49897 PyObject *swig_obj[1] ;
49898
49899 if (!args) SWIG_fail;
49900 swig_obj[0] = args;
49901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49902 if (!SWIG_IsOK(res1)) {
49903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49904 }
49905 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49906 {
49907 PyThreadState* __tstate = wxPyBeginAllowThreads();
49908 result = (int)(arg1)->GetFlexibleDirection();
49909 wxPyEndAllowThreads(__tstate);
49910 if (PyErr_Occurred()) SWIG_fail;
49911 }
49912 resultobj = SWIG_From_int(static_cast< int >(result));
49913 return resultobj;
49914 fail:
49915 return NULL;
49916 }
49917
49918
49919 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49920 PyObject *resultobj = 0;
49921 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49922 wxFlexSizerGrowMode arg2 ;
49923 void *argp1 = 0 ;
49924 int res1 = 0 ;
49925 int val2 ;
49926 int ecode2 = 0 ;
49927 PyObject * obj0 = 0 ;
49928 PyObject * obj1 = 0 ;
49929 char * kwnames[] = {
49930 (char *) "self",(char *) "mode", NULL
49931 };
49932
49933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49935 if (!SWIG_IsOK(res1)) {
49936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49937 }
49938 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49939 ecode2 = SWIG_AsVal_int(obj1, &val2);
49940 if (!SWIG_IsOK(ecode2)) {
49941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49942 }
49943 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49944 {
49945 PyThreadState* __tstate = wxPyBeginAllowThreads();
49946 (arg1)->SetNonFlexibleGrowMode(arg2);
49947 wxPyEndAllowThreads(__tstate);
49948 if (PyErr_Occurred()) SWIG_fail;
49949 }
49950 resultobj = SWIG_Py_Void();
49951 return resultobj;
49952 fail:
49953 return NULL;
49954 }
49955
49956
49957 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49958 PyObject *resultobj = 0;
49959 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49960 wxFlexSizerGrowMode result;
49961 void *argp1 = 0 ;
49962 int res1 = 0 ;
49963 PyObject *swig_obj[1] ;
49964
49965 if (!args) SWIG_fail;
49966 swig_obj[0] = args;
49967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49968 if (!SWIG_IsOK(res1)) {
49969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49970 }
49971 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49972 {
49973 PyThreadState* __tstate = wxPyBeginAllowThreads();
49974 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49975 wxPyEndAllowThreads(__tstate);
49976 if (PyErr_Occurred()) SWIG_fail;
49977 }
49978 resultobj = SWIG_From_int(static_cast< int >(result));
49979 return resultobj;
49980 fail:
49981 return NULL;
49982 }
49983
49984
49985 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49986 PyObject *resultobj = 0;
49987 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49988 wxArrayInt *result = 0 ;
49989 void *argp1 = 0 ;
49990 int res1 = 0 ;
49991 PyObject *swig_obj[1] ;
49992
49993 if (!args) SWIG_fail;
49994 swig_obj[0] = args;
49995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49996 if (!SWIG_IsOK(res1)) {
49997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49998 }
49999 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50000 {
50001 PyThreadState* __tstate = wxPyBeginAllowThreads();
50002 {
50003 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50004 result = (wxArrayInt *) &_result_ref;
50005 }
50006 wxPyEndAllowThreads(__tstate);
50007 if (PyErr_Occurred()) SWIG_fail;
50008 }
50009 {
50010 resultobj = wxArrayInt2PyList_helper(*result);
50011 }
50012 return resultobj;
50013 fail:
50014 return NULL;
50015 }
50016
50017
50018 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50019 PyObject *resultobj = 0;
50020 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50021 wxArrayInt *result = 0 ;
50022 void *argp1 = 0 ;
50023 int res1 = 0 ;
50024 PyObject *swig_obj[1] ;
50025
50026 if (!args) SWIG_fail;
50027 swig_obj[0] = args;
50028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50029 if (!SWIG_IsOK(res1)) {
50030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50031 }
50032 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50033 {
50034 PyThreadState* __tstate = wxPyBeginAllowThreads();
50035 {
50036 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50037 result = (wxArrayInt *) &_result_ref;
50038 }
50039 wxPyEndAllowThreads(__tstate);
50040 if (PyErr_Occurred()) SWIG_fail;
50041 }
50042 {
50043 resultobj = wxArrayInt2PyList_helper(*result);
50044 }
50045 return resultobj;
50046 fail:
50047 return NULL;
50048 }
50049
50050
50051 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50052 PyObject *obj;
50053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50054 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50055 return SWIG_Py_Void();
50056 }
50057
50058 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50059 return SWIG_Python_InitShadowInstance(args);
50060 }
50061
50062 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50063 PyObject *resultobj = 0;
50064 wxStdDialogButtonSizer *result = 0 ;
50065
50066 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50067 {
50068 PyThreadState* __tstate = wxPyBeginAllowThreads();
50069 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50070 wxPyEndAllowThreads(__tstate);
50071 if (PyErr_Occurred()) SWIG_fail;
50072 }
50073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50074 return resultobj;
50075 fail:
50076 return NULL;
50077 }
50078
50079
50080 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50081 PyObject *resultobj = 0;
50082 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50083 wxButton *arg2 = (wxButton *) 0 ;
50084 void *argp1 = 0 ;
50085 int res1 = 0 ;
50086 void *argp2 = 0 ;
50087 int res2 = 0 ;
50088 PyObject * obj0 = 0 ;
50089 PyObject * obj1 = 0 ;
50090 char * kwnames[] = {
50091 (char *) "self",(char *) "button", NULL
50092 };
50093
50094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50096 if (!SWIG_IsOK(res1)) {
50097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50098 }
50099 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50101 if (!SWIG_IsOK(res2)) {
50102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50103 }
50104 arg2 = reinterpret_cast< wxButton * >(argp2);
50105 {
50106 PyThreadState* __tstate = wxPyBeginAllowThreads();
50107 (arg1)->AddButton(arg2);
50108 wxPyEndAllowThreads(__tstate);
50109 if (PyErr_Occurred()) SWIG_fail;
50110 }
50111 resultobj = SWIG_Py_Void();
50112 return resultobj;
50113 fail:
50114 return NULL;
50115 }
50116
50117
50118 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50119 PyObject *resultobj = 0;
50120 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50121 void *argp1 = 0 ;
50122 int res1 = 0 ;
50123 PyObject *swig_obj[1] ;
50124
50125 if (!args) SWIG_fail;
50126 swig_obj[0] = args;
50127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50128 if (!SWIG_IsOK(res1)) {
50129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50130 }
50131 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50132 {
50133 PyThreadState* __tstate = wxPyBeginAllowThreads();
50134 (arg1)->Realize();
50135 wxPyEndAllowThreads(__tstate);
50136 if (PyErr_Occurred()) SWIG_fail;
50137 }
50138 resultobj = SWIG_Py_Void();
50139 return resultobj;
50140 fail:
50141 return NULL;
50142 }
50143
50144
50145 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50146 PyObject *resultobj = 0;
50147 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50148 wxButton *arg2 = (wxButton *) 0 ;
50149 void *argp1 = 0 ;
50150 int res1 = 0 ;
50151 void *argp2 = 0 ;
50152 int res2 = 0 ;
50153 PyObject * obj0 = 0 ;
50154 PyObject * obj1 = 0 ;
50155 char * kwnames[] = {
50156 (char *) "self",(char *) "button", NULL
50157 };
50158
50159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50161 if (!SWIG_IsOK(res1)) {
50162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50163 }
50164 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50166 if (!SWIG_IsOK(res2)) {
50167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50168 }
50169 arg2 = reinterpret_cast< wxButton * >(argp2);
50170 {
50171 PyThreadState* __tstate = wxPyBeginAllowThreads();
50172 (arg1)->SetAffirmativeButton(arg2);
50173 wxPyEndAllowThreads(__tstate);
50174 if (PyErr_Occurred()) SWIG_fail;
50175 }
50176 resultobj = SWIG_Py_Void();
50177 return resultobj;
50178 fail:
50179 return NULL;
50180 }
50181
50182
50183 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50184 PyObject *resultobj = 0;
50185 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50186 wxButton *arg2 = (wxButton *) 0 ;
50187 void *argp1 = 0 ;
50188 int res1 = 0 ;
50189 void *argp2 = 0 ;
50190 int res2 = 0 ;
50191 PyObject * obj0 = 0 ;
50192 PyObject * obj1 = 0 ;
50193 char * kwnames[] = {
50194 (char *) "self",(char *) "button", NULL
50195 };
50196
50197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50199 if (!SWIG_IsOK(res1)) {
50200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50201 }
50202 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50204 if (!SWIG_IsOK(res2)) {
50205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50206 }
50207 arg2 = reinterpret_cast< wxButton * >(argp2);
50208 {
50209 PyThreadState* __tstate = wxPyBeginAllowThreads();
50210 (arg1)->SetNegativeButton(arg2);
50211 wxPyEndAllowThreads(__tstate);
50212 if (PyErr_Occurred()) SWIG_fail;
50213 }
50214 resultobj = SWIG_Py_Void();
50215 return resultobj;
50216 fail:
50217 return NULL;
50218 }
50219
50220
50221 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50222 PyObject *resultobj = 0;
50223 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50224 wxButton *arg2 = (wxButton *) 0 ;
50225 void *argp1 = 0 ;
50226 int res1 = 0 ;
50227 void *argp2 = 0 ;
50228 int res2 = 0 ;
50229 PyObject * obj0 = 0 ;
50230 PyObject * obj1 = 0 ;
50231 char * kwnames[] = {
50232 (char *) "self",(char *) "button", NULL
50233 };
50234
50235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50237 if (!SWIG_IsOK(res1)) {
50238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50239 }
50240 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50242 if (!SWIG_IsOK(res2)) {
50243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50244 }
50245 arg2 = reinterpret_cast< wxButton * >(argp2);
50246 {
50247 PyThreadState* __tstate = wxPyBeginAllowThreads();
50248 (arg1)->SetCancelButton(arg2);
50249 wxPyEndAllowThreads(__tstate);
50250 if (PyErr_Occurred()) SWIG_fail;
50251 }
50252 resultobj = SWIG_Py_Void();
50253 return resultobj;
50254 fail:
50255 return NULL;
50256 }
50257
50258
50259 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50260 PyObject *resultobj = 0;
50261 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50262 wxButton *result = 0 ;
50263 void *argp1 = 0 ;
50264 int res1 = 0 ;
50265 PyObject *swig_obj[1] ;
50266
50267 if (!args) SWIG_fail;
50268 swig_obj[0] = args;
50269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50270 if (!SWIG_IsOK(res1)) {
50271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50272 }
50273 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50274 {
50275 PyThreadState* __tstate = wxPyBeginAllowThreads();
50276 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50277 wxPyEndAllowThreads(__tstate);
50278 if (PyErr_Occurred()) SWIG_fail;
50279 }
50280 {
50281 resultobj = wxPyMake_wxObject(result, (bool)0);
50282 }
50283 return resultobj;
50284 fail:
50285 return NULL;
50286 }
50287
50288
50289 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50290 PyObject *resultobj = 0;
50291 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50292 wxButton *result = 0 ;
50293 void *argp1 = 0 ;
50294 int res1 = 0 ;
50295 PyObject *swig_obj[1] ;
50296
50297 if (!args) SWIG_fail;
50298 swig_obj[0] = args;
50299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50300 if (!SWIG_IsOK(res1)) {
50301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50302 }
50303 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50304 {
50305 PyThreadState* __tstate = wxPyBeginAllowThreads();
50306 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50307 wxPyEndAllowThreads(__tstate);
50308 if (PyErr_Occurred()) SWIG_fail;
50309 }
50310 {
50311 resultobj = wxPyMake_wxObject(result, (bool)0);
50312 }
50313 return resultobj;
50314 fail:
50315 return NULL;
50316 }
50317
50318
50319 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50320 PyObject *resultobj = 0;
50321 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50322 wxButton *result = 0 ;
50323 void *argp1 = 0 ;
50324 int res1 = 0 ;
50325 PyObject *swig_obj[1] ;
50326
50327 if (!args) SWIG_fail;
50328 swig_obj[0] = args;
50329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50330 if (!SWIG_IsOK(res1)) {
50331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50332 }
50333 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50334 {
50335 PyThreadState* __tstate = wxPyBeginAllowThreads();
50336 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50337 wxPyEndAllowThreads(__tstate);
50338 if (PyErr_Occurred()) SWIG_fail;
50339 }
50340 {
50341 resultobj = wxPyMake_wxObject(result, (bool)0);
50342 }
50343 return resultobj;
50344 fail:
50345 return NULL;
50346 }
50347
50348
50349 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50350 PyObject *resultobj = 0;
50351 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50352 wxButton *result = 0 ;
50353 void *argp1 = 0 ;
50354 int res1 = 0 ;
50355 PyObject *swig_obj[1] ;
50356
50357 if (!args) SWIG_fail;
50358 swig_obj[0] = args;
50359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50360 if (!SWIG_IsOK(res1)) {
50361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50362 }
50363 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50367 wxPyEndAllowThreads(__tstate);
50368 if (PyErr_Occurred()) SWIG_fail;
50369 }
50370 {
50371 resultobj = wxPyMake_wxObject(result, (bool)0);
50372 }
50373 return resultobj;
50374 fail:
50375 return NULL;
50376 }
50377
50378
50379 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50380 PyObject *resultobj = 0;
50381 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50382 wxButton *result = 0 ;
50383 void *argp1 = 0 ;
50384 int res1 = 0 ;
50385 PyObject *swig_obj[1] ;
50386
50387 if (!args) SWIG_fail;
50388 swig_obj[0] = args;
50389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50390 if (!SWIG_IsOK(res1)) {
50391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50392 }
50393 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50394 {
50395 PyThreadState* __tstate = wxPyBeginAllowThreads();
50396 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50397 wxPyEndAllowThreads(__tstate);
50398 if (PyErr_Occurred()) SWIG_fail;
50399 }
50400 {
50401 resultobj = wxPyMake_wxObject(result, (bool)0);
50402 }
50403 return resultobj;
50404 fail:
50405 return NULL;
50406 }
50407
50408
50409 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50410 PyObject *obj;
50411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50412 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50413 return SWIG_Py_Void();
50414 }
50415
50416 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50417 return SWIG_Python_InitShadowInstance(args);
50418 }
50419
50420 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50421 PyObject *resultobj = 0;
50422 int arg1 = (int) 0 ;
50423 int arg2 = (int) 0 ;
50424 wxGBPosition *result = 0 ;
50425 int val1 ;
50426 int ecode1 = 0 ;
50427 int val2 ;
50428 int ecode2 = 0 ;
50429 PyObject * obj0 = 0 ;
50430 PyObject * obj1 = 0 ;
50431 char * kwnames[] = {
50432 (char *) "row",(char *) "col", NULL
50433 };
50434
50435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50436 if (obj0) {
50437 ecode1 = SWIG_AsVal_int(obj0, &val1);
50438 if (!SWIG_IsOK(ecode1)) {
50439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50440 }
50441 arg1 = static_cast< int >(val1);
50442 }
50443 if (obj1) {
50444 ecode2 = SWIG_AsVal_int(obj1, &val2);
50445 if (!SWIG_IsOK(ecode2)) {
50446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50447 }
50448 arg2 = static_cast< int >(val2);
50449 }
50450 {
50451 PyThreadState* __tstate = wxPyBeginAllowThreads();
50452 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50453 wxPyEndAllowThreads(__tstate);
50454 if (PyErr_Occurred()) SWIG_fail;
50455 }
50456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50457 return resultobj;
50458 fail:
50459 return NULL;
50460 }
50461
50462
50463 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50464 PyObject *resultobj = 0;
50465 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50466 void *argp1 = 0 ;
50467 int res1 = 0 ;
50468 PyObject *swig_obj[1] ;
50469
50470 if (!args) SWIG_fail;
50471 swig_obj[0] = args;
50472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50473 if (!SWIG_IsOK(res1)) {
50474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50475 }
50476 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50477 {
50478 PyThreadState* __tstate = wxPyBeginAllowThreads();
50479 delete arg1;
50480
50481 wxPyEndAllowThreads(__tstate);
50482 if (PyErr_Occurred()) SWIG_fail;
50483 }
50484 resultobj = SWIG_Py_Void();
50485 return resultobj;
50486 fail:
50487 return NULL;
50488 }
50489
50490
50491 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50492 PyObject *resultobj = 0;
50493 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50494 int result;
50495 void *argp1 = 0 ;
50496 int res1 = 0 ;
50497 PyObject *swig_obj[1] ;
50498
50499 if (!args) SWIG_fail;
50500 swig_obj[0] = args;
50501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50502 if (!SWIG_IsOK(res1)) {
50503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50504 }
50505 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50506 {
50507 PyThreadState* __tstate = wxPyBeginAllowThreads();
50508 result = (int)((wxGBPosition const *)arg1)->GetRow();
50509 wxPyEndAllowThreads(__tstate);
50510 if (PyErr_Occurred()) SWIG_fail;
50511 }
50512 resultobj = SWIG_From_int(static_cast< int >(result));
50513 return resultobj;
50514 fail:
50515 return NULL;
50516 }
50517
50518
50519 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50520 PyObject *resultobj = 0;
50521 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50522 int result;
50523 void *argp1 = 0 ;
50524 int res1 = 0 ;
50525 PyObject *swig_obj[1] ;
50526
50527 if (!args) SWIG_fail;
50528 swig_obj[0] = args;
50529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50530 if (!SWIG_IsOK(res1)) {
50531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50532 }
50533 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50534 {
50535 PyThreadState* __tstate = wxPyBeginAllowThreads();
50536 result = (int)((wxGBPosition const *)arg1)->GetCol();
50537 wxPyEndAllowThreads(__tstate);
50538 if (PyErr_Occurred()) SWIG_fail;
50539 }
50540 resultobj = SWIG_From_int(static_cast< int >(result));
50541 return resultobj;
50542 fail:
50543 return NULL;
50544 }
50545
50546
50547 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50548 PyObject *resultobj = 0;
50549 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50550 int arg2 ;
50551 void *argp1 = 0 ;
50552 int res1 = 0 ;
50553 int val2 ;
50554 int ecode2 = 0 ;
50555 PyObject * obj0 = 0 ;
50556 PyObject * obj1 = 0 ;
50557 char * kwnames[] = {
50558 (char *) "self",(char *) "row", NULL
50559 };
50560
50561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50563 if (!SWIG_IsOK(res1)) {
50564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50565 }
50566 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50567 ecode2 = SWIG_AsVal_int(obj1, &val2);
50568 if (!SWIG_IsOK(ecode2)) {
50569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50570 }
50571 arg2 = static_cast< int >(val2);
50572 {
50573 PyThreadState* __tstate = wxPyBeginAllowThreads();
50574 (arg1)->SetRow(arg2);
50575 wxPyEndAllowThreads(__tstate);
50576 if (PyErr_Occurred()) SWIG_fail;
50577 }
50578 resultobj = SWIG_Py_Void();
50579 return resultobj;
50580 fail:
50581 return NULL;
50582 }
50583
50584
50585 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50586 PyObject *resultobj = 0;
50587 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50588 int arg2 ;
50589 void *argp1 = 0 ;
50590 int res1 = 0 ;
50591 int val2 ;
50592 int ecode2 = 0 ;
50593 PyObject * obj0 = 0 ;
50594 PyObject * obj1 = 0 ;
50595 char * kwnames[] = {
50596 (char *) "self",(char *) "col", NULL
50597 };
50598
50599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50601 if (!SWIG_IsOK(res1)) {
50602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50603 }
50604 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50605 ecode2 = SWIG_AsVal_int(obj1, &val2);
50606 if (!SWIG_IsOK(ecode2)) {
50607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50608 }
50609 arg2 = static_cast< int >(val2);
50610 {
50611 PyThreadState* __tstate = wxPyBeginAllowThreads();
50612 (arg1)->SetCol(arg2);
50613 wxPyEndAllowThreads(__tstate);
50614 if (PyErr_Occurred()) SWIG_fail;
50615 }
50616 resultobj = SWIG_Py_Void();
50617 return resultobj;
50618 fail:
50619 return NULL;
50620 }
50621
50622
50623 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50624 PyObject *resultobj = 0;
50625 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50626 PyObject *arg2 = (PyObject *) 0 ;
50627 bool result;
50628 void *argp1 = 0 ;
50629 int res1 = 0 ;
50630 PyObject * obj0 = 0 ;
50631 PyObject * obj1 = 0 ;
50632 char * kwnames[] = {
50633 (char *) "self",(char *) "other", NULL
50634 };
50635
50636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50638 if (!SWIG_IsOK(res1)) {
50639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50640 }
50641 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50642 arg2 = obj1;
50643 {
50644 result = (bool)wxGBPosition___eq__(arg1,arg2);
50645 if (PyErr_Occurred()) SWIG_fail;
50646 }
50647 {
50648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50649 }
50650 return resultobj;
50651 fail:
50652 return NULL;
50653 }
50654
50655
50656 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50657 PyObject *resultobj = 0;
50658 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50659 PyObject *arg2 = (PyObject *) 0 ;
50660 bool result;
50661 void *argp1 = 0 ;
50662 int res1 = 0 ;
50663 PyObject * obj0 = 0 ;
50664 PyObject * obj1 = 0 ;
50665 char * kwnames[] = {
50666 (char *) "self",(char *) "other", NULL
50667 };
50668
50669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50671 if (!SWIG_IsOK(res1)) {
50672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50673 }
50674 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50675 arg2 = obj1;
50676 {
50677 result = (bool)wxGBPosition___ne__(arg1,arg2);
50678 if (PyErr_Occurred()) SWIG_fail;
50679 }
50680 {
50681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50682 }
50683 return resultobj;
50684 fail:
50685 return NULL;
50686 }
50687
50688
50689 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50690 PyObject *resultobj = 0;
50691 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50692 int arg2 = (int) 0 ;
50693 int arg3 = (int) 0 ;
50694 void *argp1 = 0 ;
50695 int res1 = 0 ;
50696 int val2 ;
50697 int ecode2 = 0 ;
50698 int val3 ;
50699 int ecode3 = 0 ;
50700 PyObject * obj0 = 0 ;
50701 PyObject * obj1 = 0 ;
50702 PyObject * obj2 = 0 ;
50703 char * kwnames[] = {
50704 (char *) "self",(char *) "row",(char *) "col", NULL
50705 };
50706
50707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50709 if (!SWIG_IsOK(res1)) {
50710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50711 }
50712 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50713 if (obj1) {
50714 ecode2 = SWIG_AsVal_int(obj1, &val2);
50715 if (!SWIG_IsOK(ecode2)) {
50716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50717 }
50718 arg2 = static_cast< int >(val2);
50719 }
50720 if (obj2) {
50721 ecode3 = SWIG_AsVal_int(obj2, &val3);
50722 if (!SWIG_IsOK(ecode3)) {
50723 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50724 }
50725 arg3 = static_cast< int >(val3);
50726 }
50727 {
50728 PyThreadState* __tstate = wxPyBeginAllowThreads();
50729 wxGBPosition_Set(arg1,arg2,arg3);
50730 wxPyEndAllowThreads(__tstate);
50731 if (PyErr_Occurred()) SWIG_fail;
50732 }
50733 resultobj = SWIG_Py_Void();
50734 return resultobj;
50735 fail:
50736 return NULL;
50737 }
50738
50739
50740 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50741 PyObject *resultobj = 0;
50742 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50743 PyObject *result = 0 ;
50744 void *argp1 = 0 ;
50745 int res1 = 0 ;
50746 PyObject *swig_obj[1] ;
50747
50748 if (!args) SWIG_fail;
50749 swig_obj[0] = args;
50750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50751 if (!SWIG_IsOK(res1)) {
50752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50753 }
50754 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50755 {
50756 PyThreadState* __tstate = wxPyBeginAllowThreads();
50757 result = (PyObject *)wxGBPosition_Get(arg1);
50758 wxPyEndAllowThreads(__tstate);
50759 if (PyErr_Occurred()) SWIG_fail;
50760 }
50761 resultobj = result;
50762 return resultobj;
50763 fail:
50764 return NULL;
50765 }
50766
50767
50768 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50769 PyObject *obj;
50770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50771 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50772 return SWIG_Py_Void();
50773 }
50774
50775 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50776 return SWIG_Python_InitShadowInstance(args);
50777 }
50778
50779 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50780 PyObject *resultobj = 0;
50781 int arg1 = (int) 1 ;
50782 int arg2 = (int) 1 ;
50783 wxGBSpan *result = 0 ;
50784 int val1 ;
50785 int ecode1 = 0 ;
50786 int val2 ;
50787 int ecode2 = 0 ;
50788 PyObject * obj0 = 0 ;
50789 PyObject * obj1 = 0 ;
50790 char * kwnames[] = {
50791 (char *) "rowspan",(char *) "colspan", NULL
50792 };
50793
50794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50795 if (obj0) {
50796 ecode1 = SWIG_AsVal_int(obj0, &val1);
50797 if (!SWIG_IsOK(ecode1)) {
50798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50799 }
50800 arg1 = static_cast< int >(val1);
50801 }
50802 if (obj1) {
50803 ecode2 = SWIG_AsVal_int(obj1, &val2);
50804 if (!SWIG_IsOK(ecode2)) {
50805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50806 }
50807 arg2 = static_cast< int >(val2);
50808 }
50809 {
50810 PyThreadState* __tstate = wxPyBeginAllowThreads();
50811 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50812 wxPyEndAllowThreads(__tstate);
50813 if (PyErr_Occurred()) SWIG_fail;
50814 }
50815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50816 return resultobj;
50817 fail:
50818 return NULL;
50819 }
50820
50821
50822 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50823 PyObject *resultobj = 0;
50824 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50825 void *argp1 = 0 ;
50826 int res1 = 0 ;
50827 PyObject *swig_obj[1] ;
50828
50829 if (!args) SWIG_fail;
50830 swig_obj[0] = args;
50831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50832 if (!SWIG_IsOK(res1)) {
50833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50834 }
50835 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50836 {
50837 PyThreadState* __tstate = wxPyBeginAllowThreads();
50838 delete arg1;
50839
50840 wxPyEndAllowThreads(__tstate);
50841 if (PyErr_Occurred()) SWIG_fail;
50842 }
50843 resultobj = SWIG_Py_Void();
50844 return resultobj;
50845 fail:
50846 return NULL;
50847 }
50848
50849
50850 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50851 PyObject *resultobj = 0;
50852 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50853 int result;
50854 void *argp1 = 0 ;
50855 int res1 = 0 ;
50856 PyObject *swig_obj[1] ;
50857
50858 if (!args) SWIG_fail;
50859 swig_obj[0] = args;
50860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50861 if (!SWIG_IsOK(res1)) {
50862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50863 }
50864 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50865 {
50866 PyThreadState* __tstate = wxPyBeginAllowThreads();
50867 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50868 wxPyEndAllowThreads(__tstate);
50869 if (PyErr_Occurred()) SWIG_fail;
50870 }
50871 resultobj = SWIG_From_int(static_cast< int >(result));
50872 return resultobj;
50873 fail:
50874 return NULL;
50875 }
50876
50877
50878 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50879 PyObject *resultobj = 0;
50880 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50881 int result;
50882 void *argp1 = 0 ;
50883 int res1 = 0 ;
50884 PyObject *swig_obj[1] ;
50885
50886 if (!args) SWIG_fail;
50887 swig_obj[0] = args;
50888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50889 if (!SWIG_IsOK(res1)) {
50890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50891 }
50892 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50893 {
50894 PyThreadState* __tstate = wxPyBeginAllowThreads();
50895 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50896 wxPyEndAllowThreads(__tstate);
50897 if (PyErr_Occurred()) SWIG_fail;
50898 }
50899 resultobj = SWIG_From_int(static_cast< int >(result));
50900 return resultobj;
50901 fail:
50902 return NULL;
50903 }
50904
50905
50906 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50907 PyObject *resultobj = 0;
50908 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50909 int arg2 ;
50910 void *argp1 = 0 ;
50911 int res1 = 0 ;
50912 int val2 ;
50913 int ecode2 = 0 ;
50914 PyObject * obj0 = 0 ;
50915 PyObject * obj1 = 0 ;
50916 char * kwnames[] = {
50917 (char *) "self",(char *) "rowspan", NULL
50918 };
50919
50920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50922 if (!SWIG_IsOK(res1)) {
50923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50924 }
50925 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50926 ecode2 = SWIG_AsVal_int(obj1, &val2);
50927 if (!SWIG_IsOK(ecode2)) {
50928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50929 }
50930 arg2 = static_cast< int >(val2);
50931 {
50932 PyThreadState* __tstate = wxPyBeginAllowThreads();
50933 (arg1)->SetRowspan(arg2);
50934 wxPyEndAllowThreads(__tstate);
50935 if (PyErr_Occurred()) SWIG_fail;
50936 }
50937 resultobj = SWIG_Py_Void();
50938 return resultobj;
50939 fail:
50940 return NULL;
50941 }
50942
50943
50944 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50945 PyObject *resultobj = 0;
50946 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50947 int arg2 ;
50948 void *argp1 = 0 ;
50949 int res1 = 0 ;
50950 int val2 ;
50951 int ecode2 = 0 ;
50952 PyObject * obj0 = 0 ;
50953 PyObject * obj1 = 0 ;
50954 char * kwnames[] = {
50955 (char *) "self",(char *) "colspan", NULL
50956 };
50957
50958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50960 if (!SWIG_IsOK(res1)) {
50961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50962 }
50963 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50964 ecode2 = SWIG_AsVal_int(obj1, &val2);
50965 if (!SWIG_IsOK(ecode2)) {
50966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50967 }
50968 arg2 = static_cast< int >(val2);
50969 {
50970 PyThreadState* __tstate = wxPyBeginAllowThreads();
50971 (arg1)->SetColspan(arg2);
50972 wxPyEndAllowThreads(__tstate);
50973 if (PyErr_Occurred()) SWIG_fail;
50974 }
50975 resultobj = SWIG_Py_Void();
50976 return resultobj;
50977 fail:
50978 return NULL;
50979 }
50980
50981
50982 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50983 PyObject *resultobj = 0;
50984 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50985 PyObject *arg2 = (PyObject *) 0 ;
50986 bool result;
50987 void *argp1 = 0 ;
50988 int res1 = 0 ;
50989 PyObject * obj0 = 0 ;
50990 PyObject * obj1 = 0 ;
50991 char * kwnames[] = {
50992 (char *) "self",(char *) "other", NULL
50993 };
50994
50995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50997 if (!SWIG_IsOK(res1)) {
50998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50999 }
51000 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51001 arg2 = obj1;
51002 {
51003 result = (bool)wxGBSpan___eq__(arg1,arg2);
51004 if (PyErr_Occurred()) SWIG_fail;
51005 }
51006 {
51007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51008 }
51009 return resultobj;
51010 fail:
51011 return NULL;
51012 }
51013
51014
51015 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51016 PyObject *resultobj = 0;
51017 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51018 PyObject *arg2 = (PyObject *) 0 ;
51019 bool result;
51020 void *argp1 = 0 ;
51021 int res1 = 0 ;
51022 PyObject * obj0 = 0 ;
51023 PyObject * obj1 = 0 ;
51024 char * kwnames[] = {
51025 (char *) "self",(char *) "other", NULL
51026 };
51027
51028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51030 if (!SWIG_IsOK(res1)) {
51031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51032 }
51033 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51034 arg2 = obj1;
51035 {
51036 result = (bool)wxGBSpan___ne__(arg1,arg2);
51037 if (PyErr_Occurred()) SWIG_fail;
51038 }
51039 {
51040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51041 }
51042 return resultobj;
51043 fail:
51044 return NULL;
51045 }
51046
51047
51048 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51049 PyObject *resultobj = 0;
51050 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51051 int arg2 = (int) 1 ;
51052 int arg3 = (int) 1 ;
51053 void *argp1 = 0 ;
51054 int res1 = 0 ;
51055 int val2 ;
51056 int ecode2 = 0 ;
51057 int val3 ;
51058 int ecode3 = 0 ;
51059 PyObject * obj0 = 0 ;
51060 PyObject * obj1 = 0 ;
51061 PyObject * obj2 = 0 ;
51062 char * kwnames[] = {
51063 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51064 };
51065
51066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51068 if (!SWIG_IsOK(res1)) {
51069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51070 }
51071 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51072 if (obj1) {
51073 ecode2 = SWIG_AsVal_int(obj1, &val2);
51074 if (!SWIG_IsOK(ecode2)) {
51075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51076 }
51077 arg2 = static_cast< int >(val2);
51078 }
51079 if (obj2) {
51080 ecode3 = SWIG_AsVal_int(obj2, &val3);
51081 if (!SWIG_IsOK(ecode3)) {
51082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51083 }
51084 arg3 = static_cast< int >(val3);
51085 }
51086 {
51087 PyThreadState* __tstate = wxPyBeginAllowThreads();
51088 wxGBSpan_Set(arg1,arg2,arg3);
51089 wxPyEndAllowThreads(__tstate);
51090 if (PyErr_Occurred()) SWIG_fail;
51091 }
51092 resultobj = SWIG_Py_Void();
51093 return resultobj;
51094 fail:
51095 return NULL;
51096 }
51097
51098
51099 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51100 PyObject *resultobj = 0;
51101 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51102 PyObject *result = 0 ;
51103 void *argp1 = 0 ;
51104 int res1 = 0 ;
51105 PyObject *swig_obj[1] ;
51106
51107 if (!args) SWIG_fail;
51108 swig_obj[0] = args;
51109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51110 if (!SWIG_IsOK(res1)) {
51111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51112 }
51113 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51114 {
51115 PyThreadState* __tstate = wxPyBeginAllowThreads();
51116 result = (PyObject *)wxGBSpan_Get(arg1);
51117 wxPyEndAllowThreads(__tstate);
51118 if (PyErr_Occurred()) SWIG_fail;
51119 }
51120 resultobj = result;
51121 return resultobj;
51122 fail:
51123 return NULL;
51124 }
51125
51126
51127 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51128 PyObject *obj;
51129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51130 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51131 return SWIG_Py_Void();
51132 }
51133
51134 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51135 return SWIG_Python_InitShadowInstance(args);
51136 }
51137
51138 SWIGINTERN int DefaultSpan_set(PyObject *) {
51139 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51140 return 1;
51141 }
51142
51143
51144 SWIGINTERN PyObject *DefaultSpan_get(void) {
51145 PyObject *pyobj = 0;
51146
51147 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51148 return pyobj;
51149 }
51150
51151
51152 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51153 PyObject *resultobj = 0;
51154 wxGBSizerItem *result = 0 ;
51155
51156 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51157 {
51158 PyThreadState* __tstate = wxPyBeginAllowThreads();
51159 result = (wxGBSizerItem *)new wxGBSizerItem();
51160 wxPyEndAllowThreads(__tstate);
51161 if (PyErr_Occurred()) SWIG_fail;
51162 }
51163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51164 return resultobj;
51165 fail:
51166 return NULL;
51167 }
51168
51169
51170 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51171 PyObject *resultobj = 0;
51172 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51173 void *argp1 = 0 ;
51174 int res1 = 0 ;
51175 PyObject *swig_obj[1] ;
51176
51177 if (!args) SWIG_fail;
51178 swig_obj[0] = args;
51179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51180 if (!SWIG_IsOK(res1)) {
51181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51182 }
51183 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51184 {
51185 PyThreadState* __tstate = wxPyBeginAllowThreads();
51186 delete arg1;
51187
51188 wxPyEndAllowThreads(__tstate);
51189 if (PyErr_Occurred()) SWIG_fail;
51190 }
51191 resultobj = SWIG_Py_Void();
51192 return resultobj;
51193 fail:
51194 return NULL;
51195 }
51196
51197
51198 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51199 PyObject *resultobj = 0;
51200 wxWindow *arg1 = (wxWindow *) 0 ;
51201 wxGBPosition *arg2 = 0 ;
51202 wxGBSpan *arg3 = 0 ;
51203 int arg4 ;
51204 int arg5 ;
51205 PyObject *arg6 = (PyObject *) NULL ;
51206 wxGBSizerItem *result = 0 ;
51207 void *argp1 = 0 ;
51208 int res1 = 0 ;
51209 wxGBPosition temp2 ;
51210 wxGBSpan temp3 ;
51211 int val4 ;
51212 int ecode4 = 0 ;
51213 int val5 ;
51214 int ecode5 = 0 ;
51215 PyObject * obj0 = 0 ;
51216 PyObject * obj1 = 0 ;
51217 PyObject * obj2 = 0 ;
51218 PyObject * obj3 = 0 ;
51219 PyObject * obj4 = 0 ;
51220 PyObject * obj5 = 0 ;
51221 char * kwnames[] = {
51222 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51223 };
51224
51225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51227 if (!SWIG_IsOK(res1)) {
51228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51229 }
51230 arg1 = reinterpret_cast< wxWindow * >(argp1);
51231 {
51232 arg2 = &temp2;
51233 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51234 }
51235 {
51236 arg3 = &temp3;
51237 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51238 }
51239 ecode4 = SWIG_AsVal_int(obj3, &val4);
51240 if (!SWIG_IsOK(ecode4)) {
51241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51242 }
51243 arg4 = static_cast< int >(val4);
51244 ecode5 = SWIG_AsVal_int(obj4, &val5);
51245 if (!SWIG_IsOK(ecode5)) {
51246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51247 }
51248 arg5 = static_cast< int >(val5);
51249 if (obj5) {
51250 arg6 = obj5;
51251 }
51252 {
51253 PyThreadState* __tstate = wxPyBeginAllowThreads();
51254 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51255 wxPyEndAllowThreads(__tstate);
51256 if (PyErr_Occurred()) SWIG_fail;
51257 }
51258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51259 return resultobj;
51260 fail:
51261 return NULL;
51262 }
51263
51264
51265 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51266 PyObject *resultobj = 0;
51267 wxSizer *arg1 = (wxSizer *) 0 ;
51268 wxGBPosition *arg2 = 0 ;
51269 wxGBSpan *arg3 = 0 ;
51270 int arg4 ;
51271 int arg5 ;
51272 PyObject *arg6 = (PyObject *) NULL ;
51273 wxGBSizerItem *result = 0 ;
51274 int res1 = 0 ;
51275 wxGBPosition temp2 ;
51276 wxGBSpan temp3 ;
51277 int val4 ;
51278 int ecode4 = 0 ;
51279 int val5 ;
51280 int ecode5 = 0 ;
51281 PyObject * obj0 = 0 ;
51282 PyObject * obj1 = 0 ;
51283 PyObject * obj2 = 0 ;
51284 PyObject * obj3 = 0 ;
51285 PyObject * obj4 = 0 ;
51286 PyObject * obj5 = 0 ;
51287 char * kwnames[] = {
51288 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51289 };
51290
51291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51292 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51293 if (!SWIG_IsOK(res1)) {
51294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51295 }
51296 {
51297 arg2 = &temp2;
51298 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51299 }
51300 {
51301 arg3 = &temp3;
51302 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51303 }
51304 ecode4 = SWIG_AsVal_int(obj3, &val4);
51305 if (!SWIG_IsOK(ecode4)) {
51306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51307 }
51308 arg4 = static_cast< int >(val4);
51309 ecode5 = SWIG_AsVal_int(obj4, &val5);
51310 if (!SWIG_IsOK(ecode5)) {
51311 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51312 }
51313 arg5 = static_cast< int >(val5);
51314 if (obj5) {
51315 arg6 = obj5;
51316 }
51317 {
51318 PyThreadState* __tstate = wxPyBeginAllowThreads();
51319 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51320 wxPyEndAllowThreads(__tstate);
51321 if (PyErr_Occurred()) SWIG_fail;
51322 }
51323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51324 return resultobj;
51325 fail:
51326 return NULL;
51327 }
51328
51329
51330 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51331 PyObject *resultobj = 0;
51332 int arg1 ;
51333 int arg2 ;
51334 wxGBPosition *arg3 = 0 ;
51335 wxGBSpan *arg4 = 0 ;
51336 int arg5 ;
51337 int arg6 ;
51338 PyObject *arg7 = (PyObject *) NULL ;
51339 wxGBSizerItem *result = 0 ;
51340 int val1 ;
51341 int ecode1 = 0 ;
51342 int val2 ;
51343 int ecode2 = 0 ;
51344 wxGBPosition temp3 ;
51345 wxGBSpan temp4 ;
51346 int val5 ;
51347 int ecode5 = 0 ;
51348 int val6 ;
51349 int ecode6 = 0 ;
51350 PyObject * obj0 = 0 ;
51351 PyObject * obj1 = 0 ;
51352 PyObject * obj2 = 0 ;
51353 PyObject * obj3 = 0 ;
51354 PyObject * obj4 = 0 ;
51355 PyObject * obj5 = 0 ;
51356 PyObject * obj6 = 0 ;
51357 char * kwnames[] = {
51358 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51359 };
51360
51361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51362 ecode1 = SWIG_AsVal_int(obj0, &val1);
51363 if (!SWIG_IsOK(ecode1)) {
51364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51365 }
51366 arg1 = static_cast< int >(val1);
51367 ecode2 = SWIG_AsVal_int(obj1, &val2);
51368 if (!SWIG_IsOK(ecode2)) {
51369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51370 }
51371 arg2 = static_cast< int >(val2);
51372 {
51373 arg3 = &temp3;
51374 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51375 }
51376 {
51377 arg4 = &temp4;
51378 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51379 }
51380 ecode5 = SWIG_AsVal_int(obj4, &val5);
51381 if (!SWIG_IsOK(ecode5)) {
51382 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51383 }
51384 arg5 = static_cast< int >(val5);
51385 ecode6 = SWIG_AsVal_int(obj5, &val6);
51386 if (!SWIG_IsOK(ecode6)) {
51387 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51388 }
51389 arg6 = static_cast< int >(val6);
51390 if (obj6) {
51391 arg7 = obj6;
51392 }
51393 {
51394 PyThreadState* __tstate = wxPyBeginAllowThreads();
51395 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51396 wxPyEndAllowThreads(__tstate);
51397 if (PyErr_Occurred()) SWIG_fail;
51398 }
51399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51400 return resultobj;
51401 fail:
51402 return NULL;
51403 }
51404
51405
51406 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51407 PyObject *resultobj = 0;
51408 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51409 wxGBPosition result;
51410 void *argp1 = 0 ;
51411 int res1 = 0 ;
51412 PyObject *swig_obj[1] ;
51413
51414 if (!args) SWIG_fail;
51415 swig_obj[0] = args;
51416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51417 if (!SWIG_IsOK(res1)) {
51418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51419 }
51420 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51421 {
51422 PyThreadState* __tstate = wxPyBeginAllowThreads();
51423 result = ((wxGBSizerItem const *)arg1)->GetPos();
51424 wxPyEndAllowThreads(__tstate);
51425 if (PyErr_Occurred()) SWIG_fail;
51426 }
51427 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51428 return resultobj;
51429 fail:
51430 return NULL;
51431 }
51432
51433
51434 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51435 PyObject *resultobj = 0;
51436 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51437 wxGBSpan result;
51438 void *argp1 = 0 ;
51439 int res1 = 0 ;
51440 PyObject *swig_obj[1] ;
51441
51442 if (!args) SWIG_fail;
51443 swig_obj[0] = args;
51444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51445 if (!SWIG_IsOK(res1)) {
51446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51447 }
51448 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51449 {
51450 PyThreadState* __tstate = wxPyBeginAllowThreads();
51451 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51452 wxPyEndAllowThreads(__tstate);
51453 if (PyErr_Occurred()) SWIG_fail;
51454 }
51455 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51456 return resultobj;
51457 fail:
51458 return NULL;
51459 }
51460
51461
51462 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51463 PyObject *resultobj = 0;
51464 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51465 wxGBPosition *arg2 = 0 ;
51466 bool result;
51467 void *argp1 = 0 ;
51468 int res1 = 0 ;
51469 wxGBPosition temp2 ;
51470 PyObject * obj0 = 0 ;
51471 PyObject * obj1 = 0 ;
51472 char * kwnames[] = {
51473 (char *) "self",(char *) "pos", NULL
51474 };
51475
51476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51478 if (!SWIG_IsOK(res1)) {
51479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51480 }
51481 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51482 {
51483 arg2 = &temp2;
51484 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51485 }
51486 {
51487 PyThreadState* __tstate = wxPyBeginAllowThreads();
51488 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51489 wxPyEndAllowThreads(__tstate);
51490 if (PyErr_Occurred()) SWIG_fail;
51491 }
51492 {
51493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51494 }
51495 return resultobj;
51496 fail:
51497 return NULL;
51498 }
51499
51500
51501 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51502 PyObject *resultobj = 0;
51503 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51504 wxGBSpan *arg2 = 0 ;
51505 bool result;
51506 void *argp1 = 0 ;
51507 int res1 = 0 ;
51508 wxGBSpan temp2 ;
51509 PyObject * obj0 = 0 ;
51510 PyObject * obj1 = 0 ;
51511 char * kwnames[] = {
51512 (char *) "self",(char *) "span", NULL
51513 };
51514
51515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51517 if (!SWIG_IsOK(res1)) {
51518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51519 }
51520 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51521 {
51522 arg2 = &temp2;
51523 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51524 }
51525 {
51526 PyThreadState* __tstate = wxPyBeginAllowThreads();
51527 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51528 wxPyEndAllowThreads(__tstate);
51529 if (PyErr_Occurred()) SWIG_fail;
51530 }
51531 {
51532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51533 }
51534 return resultobj;
51535 fail:
51536 return NULL;
51537 }
51538
51539
51540 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51541 PyObject *resultobj = 0;
51542 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51543 wxGBSizerItem *arg2 = 0 ;
51544 bool result;
51545 void *argp1 = 0 ;
51546 int res1 = 0 ;
51547 void *argp2 = 0 ;
51548 int res2 = 0 ;
51549 PyObject * obj0 = 0 ;
51550 PyObject * obj1 = 0 ;
51551 char * kwnames[] = {
51552 (char *) "self",(char *) "other", NULL
51553 };
51554
51555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51557 if (!SWIG_IsOK(res1)) {
51558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51559 }
51560 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51562 if (!SWIG_IsOK(res2)) {
51563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51564 }
51565 if (!argp2) {
51566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51567 }
51568 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51569 {
51570 PyThreadState* __tstate = wxPyBeginAllowThreads();
51571 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51572 wxPyEndAllowThreads(__tstate);
51573 if (PyErr_Occurred()) SWIG_fail;
51574 }
51575 {
51576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51577 }
51578 return resultobj;
51579 fail:
51580 return NULL;
51581 }
51582
51583
51584 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51585 PyObject *resultobj = 0;
51586 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51587 wxGBPosition *arg2 = 0 ;
51588 wxGBSpan *arg3 = 0 ;
51589 bool result;
51590 void *argp1 = 0 ;
51591 int res1 = 0 ;
51592 wxGBPosition temp2 ;
51593 wxGBSpan temp3 ;
51594 PyObject * obj0 = 0 ;
51595 PyObject * obj1 = 0 ;
51596 PyObject * obj2 = 0 ;
51597 char * kwnames[] = {
51598 (char *) "self",(char *) "pos",(char *) "span", NULL
51599 };
51600
51601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51603 if (!SWIG_IsOK(res1)) {
51604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51605 }
51606 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51607 {
51608 arg2 = &temp2;
51609 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51610 }
51611 {
51612 arg3 = &temp3;
51613 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51614 }
51615 {
51616 PyThreadState* __tstate = wxPyBeginAllowThreads();
51617 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51618 wxPyEndAllowThreads(__tstate);
51619 if (PyErr_Occurred()) SWIG_fail;
51620 }
51621 {
51622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51623 }
51624 return resultobj;
51625 fail:
51626 return NULL;
51627 }
51628
51629
51630 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51631 PyObject *resultobj = 0;
51632 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51633 wxGBPosition result;
51634 void *argp1 = 0 ;
51635 int res1 = 0 ;
51636 PyObject *swig_obj[1] ;
51637
51638 if (!args) SWIG_fail;
51639 swig_obj[0] = args;
51640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51641 if (!SWIG_IsOK(res1)) {
51642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51643 }
51644 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 result = wxGBSizerItem_GetEndPos(arg1);
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51652 return resultobj;
51653 fail:
51654 return NULL;
51655 }
51656
51657
51658 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51659 PyObject *resultobj = 0;
51660 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51661 wxGridBagSizer *result = 0 ;
51662 void *argp1 = 0 ;
51663 int res1 = 0 ;
51664 PyObject *swig_obj[1] ;
51665
51666 if (!args) SWIG_fail;
51667 swig_obj[0] = args;
51668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51669 if (!SWIG_IsOK(res1)) {
51670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51671 }
51672 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51673 {
51674 PyThreadState* __tstate = wxPyBeginAllowThreads();
51675 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51676 wxPyEndAllowThreads(__tstate);
51677 if (PyErr_Occurred()) SWIG_fail;
51678 }
51679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51680 return resultobj;
51681 fail:
51682 return NULL;
51683 }
51684
51685
51686 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51687 PyObject *resultobj = 0;
51688 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51689 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51690 void *argp1 = 0 ;
51691 int res1 = 0 ;
51692 void *argp2 = 0 ;
51693 int res2 = 0 ;
51694 PyObject * obj0 = 0 ;
51695 PyObject * obj1 = 0 ;
51696 char * kwnames[] = {
51697 (char *) "self",(char *) "sizer", NULL
51698 };
51699
51700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51702 if (!SWIG_IsOK(res1)) {
51703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51704 }
51705 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51706 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51707 if (!SWIG_IsOK(res2)) {
51708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51709 }
51710 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51711 {
51712 PyThreadState* __tstate = wxPyBeginAllowThreads();
51713 (arg1)->SetGBSizer(arg2);
51714 wxPyEndAllowThreads(__tstate);
51715 if (PyErr_Occurred()) SWIG_fail;
51716 }
51717 resultobj = SWIG_Py_Void();
51718 return resultobj;
51719 fail:
51720 return NULL;
51721 }
51722
51723
51724 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51725 PyObject *obj;
51726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51727 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51728 return SWIG_Py_Void();
51729 }
51730
51731 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51732 return SWIG_Python_InitShadowInstance(args);
51733 }
51734
51735 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51736 PyObject *resultobj = 0;
51737 int arg1 = (int) 0 ;
51738 int arg2 = (int) 0 ;
51739 wxGridBagSizer *result = 0 ;
51740 int val1 ;
51741 int ecode1 = 0 ;
51742 int val2 ;
51743 int ecode2 = 0 ;
51744 PyObject * obj0 = 0 ;
51745 PyObject * obj1 = 0 ;
51746 char * kwnames[] = {
51747 (char *) "vgap",(char *) "hgap", NULL
51748 };
51749
51750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51751 if (obj0) {
51752 ecode1 = SWIG_AsVal_int(obj0, &val1);
51753 if (!SWIG_IsOK(ecode1)) {
51754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51755 }
51756 arg1 = static_cast< int >(val1);
51757 }
51758 if (obj1) {
51759 ecode2 = SWIG_AsVal_int(obj1, &val2);
51760 if (!SWIG_IsOK(ecode2)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51762 }
51763 arg2 = static_cast< int >(val2);
51764 }
51765 {
51766 PyThreadState* __tstate = wxPyBeginAllowThreads();
51767 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51768 wxPyEndAllowThreads(__tstate);
51769 if (PyErr_Occurred()) SWIG_fail;
51770 }
51771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51772 return resultobj;
51773 fail:
51774 return NULL;
51775 }
51776
51777
51778 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51779 PyObject *resultobj = 0;
51780 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51781 PyObject *arg2 = (PyObject *) 0 ;
51782 wxGBPosition *arg3 = 0 ;
51783 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51784 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51785 int arg5 = (int) 0 ;
51786 int arg6 = (int) 0 ;
51787 PyObject *arg7 = (PyObject *) NULL ;
51788 wxGBSizerItem *result = 0 ;
51789 void *argp1 = 0 ;
51790 int res1 = 0 ;
51791 wxGBPosition temp3 ;
51792 wxGBSpan temp4 ;
51793 int val5 ;
51794 int ecode5 = 0 ;
51795 int val6 ;
51796 int ecode6 = 0 ;
51797 PyObject * obj0 = 0 ;
51798 PyObject * obj1 = 0 ;
51799 PyObject * obj2 = 0 ;
51800 PyObject * obj3 = 0 ;
51801 PyObject * obj4 = 0 ;
51802 PyObject * obj5 = 0 ;
51803 PyObject * obj6 = 0 ;
51804 char * kwnames[] = {
51805 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51806 };
51807
51808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51810 if (!SWIG_IsOK(res1)) {
51811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51812 }
51813 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51814 arg2 = obj1;
51815 {
51816 arg3 = &temp3;
51817 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51818 }
51819 if (obj3) {
51820 {
51821 arg4 = &temp4;
51822 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51823 }
51824 }
51825 if (obj4) {
51826 ecode5 = SWIG_AsVal_int(obj4, &val5);
51827 if (!SWIG_IsOK(ecode5)) {
51828 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51829 }
51830 arg5 = static_cast< int >(val5);
51831 }
51832 if (obj5) {
51833 ecode6 = SWIG_AsVal_int(obj5, &val6);
51834 if (!SWIG_IsOK(ecode6)) {
51835 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51836 }
51837 arg6 = static_cast< int >(val6);
51838 }
51839 if (obj6) {
51840 arg7 = obj6;
51841 }
51842 {
51843 PyThreadState* __tstate = wxPyBeginAllowThreads();
51844 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51845 wxPyEndAllowThreads(__tstate);
51846 if (PyErr_Occurred()) SWIG_fail;
51847 }
51848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51849 return resultobj;
51850 fail:
51851 return NULL;
51852 }
51853
51854
51855 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51856 PyObject *resultobj = 0;
51857 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51858 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51859 wxGBSizerItem *result = 0 ;
51860 void *argp1 = 0 ;
51861 int res1 = 0 ;
51862 int res2 = 0 ;
51863 PyObject * obj0 = 0 ;
51864 PyObject * obj1 = 0 ;
51865 char * kwnames[] = {
51866 (char *) "self",(char *) "item", NULL
51867 };
51868
51869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51871 if (!SWIG_IsOK(res1)) {
51872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51873 }
51874 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51875 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51876 if (!SWIG_IsOK(res2)) {
51877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51878 }
51879 {
51880 PyThreadState* __tstate = wxPyBeginAllowThreads();
51881 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51882 wxPyEndAllowThreads(__tstate);
51883 if (PyErr_Occurred()) SWIG_fail;
51884 }
51885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51886 return resultobj;
51887 fail:
51888 return NULL;
51889 }
51890
51891
51892 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51893 PyObject *resultobj = 0;
51894 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51895 int arg2 ;
51896 int arg3 ;
51897 wxSize result;
51898 void *argp1 = 0 ;
51899 int res1 = 0 ;
51900 int val2 ;
51901 int ecode2 = 0 ;
51902 int val3 ;
51903 int ecode3 = 0 ;
51904 PyObject * obj0 = 0 ;
51905 PyObject * obj1 = 0 ;
51906 PyObject * obj2 = 0 ;
51907 char * kwnames[] = {
51908 (char *) "self",(char *) "row",(char *) "col", NULL
51909 };
51910
51911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51913 if (!SWIG_IsOK(res1)) {
51914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51915 }
51916 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51917 ecode2 = SWIG_AsVal_int(obj1, &val2);
51918 if (!SWIG_IsOK(ecode2)) {
51919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51920 }
51921 arg2 = static_cast< int >(val2);
51922 ecode3 = SWIG_AsVal_int(obj2, &val3);
51923 if (!SWIG_IsOK(ecode3)) {
51924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51925 }
51926 arg3 = static_cast< int >(val3);
51927 {
51928 PyThreadState* __tstate = wxPyBeginAllowThreads();
51929 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51930 wxPyEndAllowThreads(__tstate);
51931 if (PyErr_Occurred()) SWIG_fail;
51932 }
51933 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51934 return resultobj;
51935 fail:
51936 return NULL;
51937 }
51938
51939
51940 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51941 PyObject *resultobj = 0;
51942 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51943 wxSize result;
51944 void *argp1 = 0 ;
51945 int res1 = 0 ;
51946 PyObject *swig_obj[1] ;
51947
51948 if (!args) SWIG_fail;
51949 swig_obj[0] = args;
51950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51951 if (!SWIG_IsOK(res1)) {
51952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51953 }
51954 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51955 {
51956 PyThreadState* __tstate = wxPyBeginAllowThreads();
51957 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51958 wxPyEndAllowThreads(__tstate);
51959 if (PyErr_Occurred()) SWIG_fail;
51960 }
51961 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51962 return resultobj;
51963 fail:
51964 return NULL;
51965 }
51966
51967
51968 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51969 PyObject *resultobj = 0;
51970 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51971 wxSize *arg2 = 0 ;
51972 void *argp1 = 0 ;
51973 int res1 = 0 ;
51974 wxSize temp2 ;
51975 PyObject * obj0 = 0 ;
51976 PyObject * obj1 = 0 ;
51977 char * kwnames[] = {
51978 (char *) "self",(char *) "sz", NULL
51979 };
51980
51981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51983 if (!SWIG_IsOK(res1)) {
51984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51985 }
51986 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51987 {
51988 arg2 = &temp2;
51989 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51990 }
51991 {
51992 PyThreadState* __tstate = wxPyBeginAllowThreads();
51993 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51994 wxPyEndAllowThreads(__tstate);
51995 if (PyErr_Occurred()) SWIG_fail;
51996 }
51997 resultobj = SWIG_Py_Void();
51998 return resultobj;
51999 fail:
52000 return NULL;
52001 }
52002
52003
52004 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52005 PyObject *resultobj = 0;
52006 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52007 wxWindow *arg2 = (wxWindow *) 0 ;
52008 wxGBPosition result;
52009 void *argp1 = 0 ;
52010 int res1 = 0 ;
52011 void *argp2 = 0 ;
52012 int res2 = 0 ;
52013
52014 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52016 if (!SWIG_IsOK(res1)) {
52017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52018 }
52019 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52020 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52021 if (!SWIG_IsOK(res2)) {
52022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52023 }
52024 arg2 = reinterpret_cast< wxWindow * >(argp2);
52025 {
52026 PyThreadState* __tstate = wxPyBeginAllowThreads();
52027 result = (arg1)->GetItemPosition(arg2);
52028 wxPyEndAllowThreads(__tstate);
52029 if (PyErr_Occurred()) SWIG_fail;
52030 }
52031 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52032 return resultobj;
52033 fail:
52034 return NULL;
52035 }
52036
52037
52038 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52039 PyObject *resultobj = 0;
52040 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52041 wxSizer *arg2 = (wxSizer *) 0 ;
52042 wxGBPosition result;
52043 void *argp1 = 0 ;
52044 int res1 = 0 ;
52045 void *argp2 = 0 ;
52046 int res2 = 0 ;
52047
52048 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52050 if (!SWIG_IsOK(res1)) {
52051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52052 }
52053 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52054 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52055 if (!SWIG_IsOK(res2)) {
52056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52057 }
52058 arg2 = reinterpret_cast< wxSizer * >(argp2);
52059 {
52060 PyThreadState* __tstate = wxPyBeginAllowThreads();
52061 result = (arg1)->GetItemPosition(arg2);
52062 wxPyEndAllowThreads(__tstate);
52063 if (PyErr_Occurred()) SWIG_fail;
52064 }
52065 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52066 return resultobj;
52067 fail:
52068 return NULL;
52069 }
52070
52071
52072 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52073 PyObject *resultobj = 0;
52074 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52075 size_t arg2 ;
52076 wxGBPosition result;
52077 void *argp1 = 0 ;
52078 int res1 = 0 ;
52079 size_t val2 ;
52080 int ecode2 = 0 ;
52081
52082 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52084 if (!SWIG_IsOK(res1)) {
52085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52086 }
52087 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52088 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52089 if (!SWIG_IsOK(ecode2)) {
52090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52091 }
52092 arg2 = static_cast< size_t >(val2);
52093 {
52094 PyThreadState* __tstate = wxPyBeginAllowThreads();
52095 result = (arg1)->GetItemPosition(arg2);
52096 wxPyEndAllowThreads(__tstate);
52097 if (PyErr_Occurred()) SWIG_fail;
52098 }
52099 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52100 return resultobj;
52101 fail:
52102 return NULL;
52103 }
52104
52105
52106 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52107 int argc;
52108 PyObject *argv[3];
52109
52110 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52111 --argc;
52112 if (argc == 2) {
52113 int _v = 0;
52114 {
52115 void *vptr = 0;
52116 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52117 _v = SWIG_CheckState(res);
52118 }
52119 if (!_v) goto check_1;
52120 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52121 }
52122 check_1:
52123
52124 if (argc == 2) {
52125 int _v = 0;
52126 {
52127 void *vptr = 0;
52128 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52129 _v = SWIG_CheckState(res);
52130 }
52131 if (!_v) goto check_2;
52132 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52133 }
52134 check_2:
52135
52136 if (argc == 2) {
52137 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52138 }
52139
52140 fail:
52141 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52142 return NULL;
52143 }
52144
52145
52146 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52147 PyObject *resultobj = 0;
52148 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52149 wxWindow *arg2 = (wxWindow *) 0 ;
52150 wxGBPosition *arg3 = 0 ;
52151 bool result;
52152 void *argp1 = 0 ;
52153 int res1 = 0 ;
52154 void *argp2 = 0 ;
52155 int res2 = 0 ;
52156 wxGBPosition temp3 ;
52157
52158 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52160 if (!SWIG_IsOK(res1)) {
52161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52162 }
52163 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52164 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52165 if (!SWIG_IsOK(res2)) {
52166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52167 }
52168 arg2 = reinterpret_cast< wxWindow * >(argp2);
52169 {
52170 arg3 = &temp3;
52171 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52172 }
52173 {
52174 PyThreadState* __tstate = wxPyBeginAllowThreads();
52175 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52176 wxPyEndAllowThreads(__tstate);
52177 if (PyErr_Occurred()) SWIG_fail;
52178 }
52179 {
52180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52181 }
52182 return resultobj;
52183 fail:
52184 return NULL;
52185 }
52186
52187
52188 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52189 PyObject *resultobj = 0;
52190 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52191 wxSizer *arg2 = (wxSizer *) 0 ;
52192 wxGBPosition *arg3 = 0 ;
52193 bool result;
52194 void *argp1 = 0 ;
52195 int res1 = 0 ;
52196 void *argp2 = 0 ;
52197 int res2 = 0 ;
52198 wxGBPosition temp3 ;
52199
52200 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52202 if (!SWIG_IsOK(res1)) {
52203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52204 }
52205 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52206 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52207 if (!SWIG_IsOK(res2)) {
52208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52209 }
52210 arg2 = reinterpret_cast< wxSizer * >(argp2);
52211 {
52212 arg3 = &temp3;
52213 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52214 }
52215 {
52216 PyThreadState* __tstate = wxPyBeginAllowThreads();
52217 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52218 wxPyEndAllowThreads(__tstate);
52219 if (PyErr_Occurred()) SWIG_fail;
52220 }
52221 {
52222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52223 }
52224 return resultobj;
52225 fail:
52226 return NULL;
52227 }
52228
52229
52230 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52231 PyObject *resultobj = 0;
52232 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52233 size_t arg2 ;
52234 wxGBPosition *arg3 = 0 ;
52235 bool result;
52236 void *argp1 = 0 ;
52237 int res1 = 0 ;
52238 size_t val2 ;
52239 int ecode2 = 0 ;
52240 wxGBPosition temp3 ;
52241
52242 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52244 if (!SWIG_IsOK(res1)) {
52245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52246 }
52247 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52248 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52249 if (!SWIG_IsOK(ecode2)) {
52250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52251 }
52252 arg2 = static_cast< size_t >(val2);
52253 {
52254 arg3 = &temp3;
52255 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52256 }
52257 {
52258 PyThreadState* __tstate = wxPyBeginAllowThreads();
52259 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52260 wxPyEndAllowThreads(__tstate);
52261 if (PyErr_Occurred()) SWIG_fail;
52262 }
52263 {
52264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52265 }
52266 return resultobj;
52267 fail:
52268 return NULL;
52269 }
52270
52271
52272 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52273 int argc;
52274 PyObject *argv[4];
52275
52276 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52277 --argc;
52278 if (argc == 3) {
52279 int _v = 0;
52280 {
52281 void *vptr = 0;
52282 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52283 _v = SWIG_CheckState(res);
52284 }
52285 if (!_v) goto check_1;
52286 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52287 }
52288 check_1:
52289
52290 if (argc == 3) {
52291 int _v = 0;
52292 {
52293 void *vptr = 0;
52294 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52295 _v = SWIG_CheckState(res);
52296 }
52297 if (!_v) goto check_2;
52298 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52299 }
52300 check_2:
52301
52302 if (argc == 3) {
52303 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52304 }
52305
52306 fail:
52307 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52313 PyObject *resultobj = 0;
52314 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52315 wxWindow *arg2 = (wxWindow *) 0 ;
52316 wxGBSpan result;
52317 void *argp1 = 0 ;
52318 int res1 = 0 ;
52319 void *argp2 = 0 ;
52320 int res2 = 0 ;
52321
52322 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52324 if (!SWIG_IsOK(res1)) {
52325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52326 }
52327 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52328 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52329 if (!SWIG_IsOK(res2)) {
52330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52331 }
52332 arg2 = reinterpret_cast< wxWindow * >(argp2);
52333 {
52334 PyThreadState* __tstate = wxPyBeginAllowThreads();
52335 result = (arg1)->GetItemSpan(arg2);
52336 wxPyEndAllowThreads(__tstate);
52337 if (PyErr_Occurred()) SWIG_fail;
52338 }
52339 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52340 return resultobj;
52341 fail:
52342 return NULL;
52343 }
52344
52345
52346 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52347 PyObject *resultobj = 0;
52348 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52349 wxSizer *arg2 = (wxSizer *) 0 ;
52350 wxGBSpan result;
52351 void *argp1 = 0 ;
52352 int res1 = 0 ;
52353 void *argp2 = 0 ;
52354 int res2 = 0 ;
52355
52356 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52358 if (!SWIG_IsOK(res1)) {
52359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52360 }
52361 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52362 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52363 if (!SWIG_IsOK(res2)) {
52364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52365 }
52366 arg2 = reinterpret_cast< wxSizer * >(argp2);
52367 {
52368 PyThreadState* __tstate = wxPyBeginAllowThreads();
52369 result = (arg1)->GetItemSpan(arg2);
52370 wxPyEndAllowThreads(__tstate);
52371 if (PyErr_Occurred()) SWIG_fail;
52372 }
52373 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52374 return resultobj;
52375 fail:
52376 return NULL;
52377 }
52378
52379
52380 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52381 PyObject *resultobj = 0;
52382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52383 size_t arg2 ;
52384 wxGBSpan result;
52385 void *argp1 = 0 ;
52386 int res1 = 0 ;
52387 size_t val2 ;
52388 int ecode2 = 0 ;
52389
52390 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52392 if (!SWIG_IsOK(res1)) {
52393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52394 }
52395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52396 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52397 if (!SWIG_IsOK(ecode2)) {
52398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52399 }
52400 arg2 = static_cast< size_t >(val2);
52401 {
52402 PyThreadState* __tstate = wxPyBeginAllowThreads();
52403 result = (arg1)->GetItemSpan(arg2);
52404 wxPyEndAllowThreads(__tstate);
52405 if (PyErr_Occurred()) SWIG_fail;
52406 }
52407 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52408 return resultobj;
52409 fail:
52410 return NULL;
52411 }
52412
52413
52414 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52415 int argc;
52416 PyObject *argv[3];
52417
52418 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52419 --argc;
52420 if (argc == 2) {
52421 int _v = 0;
52422 {
52423 void *vptr = 0;
52424 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52425 _v = SWIG_CheckState(res);
52426 }
52427 if (!_v) goto check_1;
52428 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52429 }
52430 check_1:
52431
52432 if (argc == 2) {
52433 int _v = 0;
52434 {
52435 void *vptr = 0;
52436 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52437 _v = SWIG_CheckState(res);
52438 }
52439 if (!_v) goto check_2;
52440 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52441 }
52442 check_2:
52443
52444 if (argc == 2) {
52445 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52446 }
52447
52448 fail:
52449 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52450 return NULL;
52451 }
52452
52453
52454 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52455 PyObject *resultobj = 0;
52456 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52457 wxWindow *arg2 = (wxWindow *) 0 ;
52458 wxGBSpan *arg3 = 0 ;
52459 bool result;
52460 void *argp1 = 0 ;
52461 int res1 = 0 ;
52462 void *argp2 = 0 ;
52463 int res2 = 0 ;
52464 wxGBSpan temp3 ;
52465
52466 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52468 if (!SWIG_IsOK(res1)) {
52469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52470 }
52471 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52472 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52473 if (!SWIG_IsOK(res2)) {
52474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52475 }
52476 arg2 = reinterpret_cast< wxWindow * >(argp2);
52477 {
52478 arg3 = &temp3;
52479 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52480 }
52481 {
52482 PyThreadState* __tstate = wxPyBeginAllowThreads();
52483 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52484 wxPyEndAllowThreads(__tstate);
52485 if (PyErr_Occurred()) SWIG_fail;
52486 }
52487 {
52488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52489 }
52490 return resultobj;
52491 fail:
52492 return NULL;
52493 }
52494
52495
52496 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52497 PyObject *resultobj = 0;
52498 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52499 wxSizer *arg2 = (wxSizer *) 0 ;
52500 wxGBSpan *arg3 = 0 ;
52501 bool result;
52502 void *argp1 = 0 ;
52503 int res1 = 0 ;
52504 void *argp2 = 0 ;
52505 int res2 = 0 ;
52506 wxGBSpan temp3 ;
52507
52508 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52510 if (!SWIG_IsOK(res1)) {
52511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52512 }
52513 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52515 if (!SWIG_IsOK(res2)) {
52516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52517 }
52518 arg2 = reinterpret_cast< wxSizer * >(argp2);
52519 {
52520 arg3 = &temp3;
52521 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52522 }
52523 {
52524 PyThreadState* __tstate = wxPyBeginAllowThreads();
52525 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52526 wxPyEndAllowThreads(__tstate);
52527 if (PyErr_Occurred()) SWIG_fail;
52528 }
52529 {
52530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52531 }
52532 return resultobj;
52533 fail:
52534 return NULL;
52535 }
52536
52537
52538 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52539 PyObject *resultobj = 0;
52540 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52541 size_t arg2 ;
52542 wxGBSpan *arg3 = 0 ;
52543 bool result;
52544 void *argp1 = 0 ;
52545 int res1 = 0 ;
52546 size_t val2 ;
52547 int ecode2 = 0 ;
52548 wxGBSpan temp3 ;
52549
52550 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52552 if (!SWIG_IsOK(res1)) {
52553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52554 }
52555 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52556 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52557 if (!SWIG_IsOK(ecode2)) {
52558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52559 }
52560 arg2 = static_cast< size_t >(val2);
52561 {
52562 arg3 = &temp3;
52563 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52564 }
52565 {
52566 PyThreadState* __tstate = wxPyBeginAllowThreads();
52567 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52568 wxPyEndAllowThreads(__tstate);
52569 if (PyErr_Occurred()) SWIG_fail;
52570 }
52571 {
52572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52573 }
52574 return resultobj;
52575 fail:
52576 return NULL;
52577 }
52578
52579
52580 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52581 int argc;
52582 PyObject *argv[4];
52583
52584 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52585 --argc;
52586 if (argc == 3) {
52587 int _v = 0;
52588 {
52589 void *vptr = 0;
52590 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52591 _v = SWIG_CheckState(res);
52592 }
52593 if (!_v) goto check_1;
52594 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52595 }
52596 check_1:
52597
52598 if (argc == 3) {
52599 int _v = 0;
52600 {
52601 void *vptr = 0;
52602 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52603 _v = SWIG_CheckState(res);
52604 }
52605 if (!_v) goto check_2;
52606 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52607 }
52608 check_2:
52609
52610 if (argc == 3) {
52611 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52612 }
52613
52614 fail:
52615 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52616 return NULL;
52617 }
52618
52619
52620 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52621 PyObject *resultobj = 0;
52622 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52623 wxWindow *arg2 = (wxWindow *) 0 ;
52624 wxGBSizerItem *result = 0 ;
52625 void *argp1 = 0 ;
52626 int res1 = 0 ;
52627 void *argp2 = 0 ;
52628 int res2 = 0 ;
52629
52630 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52632 if (!SWIG_IsOK(res1)) {
52633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52634 }
52635 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52636 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52637 if (!SWIG_IsOK(res2)) {
52638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52639 }
52640 arg2 = reinterpret_cast< wxWindow * >(argp2);
52641 {
52642 PyThreadState* __tstate = wxPyBeginAllowThreads();
52643 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52644 wxPyEndAllowThreads(__tstate);
52645 if (PyErr_Occurred()) SWIG_fail;
52646 }
52647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52648 return resultobj;
52649 fail:
52650 return NULL;
52651 }
52652
52653
52654 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52655 PyObject *resultobj = 0;
52656 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52657 wxSizer *arg2 = (wxSizer *) 0 ;
52658 wxGBSizerItem *result = 0 ;
52659 void *argp1 = 0 ;
52660 int res1 = 0 ;
52661 void *argp2 = 0 ;
52662 int res2 = 0 ;
52663
52664 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52666 if (!SWIG_IsOK(res1)) {
52667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52668 }
52669 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52670 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52671 if (!SWIG_IsOK(res2)) {
52672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52673 }
52674 arg2 = reinterpret_cast< wxSizer * >(argp2);
52675 {
52676 PyThreadState* __tstate = wxPyBeginAllowThreads();
52677 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52678 wxPyEndAllowThreads(__tstate);
52679 if (PyErr_Occurred()) SWIG_fail;
52680 }
52681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52682 return resultobj;
52683 fail:
52684 return NULL;
52685 }
52686
52687
52688 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52689 int argc;
52690 PyObject *argv[3];
52691
52692 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52693 --argc;
52694 if (argc == 2) {
52695 int _v = 0;
52696 {
52697 void *vptr = 0;
52698 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52699 _v = SWIG_CheckState(res);
52700 }
52701 if (!_v) goto check_1;
52702 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52703 }
52704 check_1:
52705
52706 if (argc == 2) {
52707 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52708 }
52709
52710 fail:
52711 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52712 return NULL;
52713 }
52714
52715
52716 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52717 PyObject *resultobj = 0;
52718 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52719 wxGBPosition *arg2 = 0 ;
52720 wxGBSizerItem *result = 0 ;
52721 void *argp1 = 0 ;
52722 int res1 = 0 ;
52723 wxGBPosition temp2 ;
52724 PyObject * obj0 = 0 ;
52725 PyObject * obj1 = 0 ;
52726 char * kwnames[] = {
52727 (char *) "self",(char *) "pos", NULL
52728 };
52729
52730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52732 if (!SWIG_IsOK(res1)) {
52733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52734 }
52735 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52736 {
52737 arg2 = &temp2;
52738 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52739 }
52740 {
52741 PyThreadState* __tstate = wxPyBeginAllowThreads();
52742 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52743 wxPyEndAllowThreads(__tstate);
52744 if (PyErr_Occurred()) SWIG_fail;
52745 }
52746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52747 return resultobj;
52748 fail:
52749 return NULL;
52750 }
52751
52752
52753 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52754 PyObject *resultobj = 0;
52755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52756 wxPoint *arg2 = 0 ;
52757 wxGBSizerItem *result = 0 ;
52758 void *argp1 = 0 ;
52759 int res1 = 0 ;
52760 wxPoint temp2 ;
52761 PyObject * obj0 = 0 ;
52762 PyObject * obj1 = 0 ;
52763 char * kwnames[] = {
52764 (char *) "self",(char *) "pt", NULL
52765 };
52766
52767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52769 if (!SWIG_IsOK(res1)) {
52770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52771 }
52772 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52773 {
52774 arg2 = &temp2;
52775 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52776 }
52777 {
52778 PyThreadState* __tstate = wxPyBeginAllowThreads();
52779 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52780 wxPyEndAllowThreads(__tstate);
52781 if (PyErr_Occurred()) SWIG_fail;
52782 }
52783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52784 return resultobj;
52785 fail:
52786 return NULL;
52787 }
52788
52789
52790 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52791 PyObject *resultobj = 0;
52792 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52793 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52794 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52795 bool result;
52796 void *argp1 = 0 ;
52797 int res1 = 0 ;
52798 void *argp2 = 0 ;
52799 int res2 = 0 ;
52800 void *argp3 = 0 ;
52801 int res3 = 0 ;
52802 PyObject * obj0 = 0 ;
52803 PyObject * obj1 = 0 ;
52804 PyObject * obj2 = 0 ;
52805 char * kwnames[] = {
52806 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52807 };
52808
52809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52811 if (!SWIG_IsOK(res1)) {
52812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52813 }
52814 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52816 if (!SWIG_IsOK(res2)) {
52817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52818 }
52819 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52820 if (obj2) {
52821 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52822 if (!SWIG_IsOK(res3)) {
52823 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52824 }
52825 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52826 }
52827 {
52828 PyThreadState* __tstate = wxPyBeginAllowThreads();
52829 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52830 wxPyEndAllowThreads(__tstate);
52831 if (PyErr_Occurred()) SWIG_fail;
52832 }
52833 {
52834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52835 }
52836 return resultobj;
52837 fail:
52838 return NULL;
52839 }
52840
52841
52842 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52843 PyObject *resultobj = 0;
52844 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52845 wxGBPosition *arg2 = 0 ;
52846 wxGBSpan *arg3 = 0 ;
52847 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52848 bool result;
52849 void *argp1 = 0 ;
52850 int res1 = 0 ;
52851 wxGBPosition temp2 ;
52852 wxGBSpan temp3 ;
52853 void *argp4 = 0 ;
52854 int res4 = 0 ;
52855 PyObject * obj0 = 0 ;
52856 PyObject * obj1 = 0 ;
52857 PyObject * obj2 = 0 ;
52858 PyObject * obj3 = 0 ;
52859 char * kwnames[] = {
52860 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52861 };
52862
52863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52865 if (!SWIG_IsOK(res1)) {
52866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52867 }
52868 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52869 {
52870 arg2 = &temp2;
52871 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52872 }
52873 {
52874 arg3 = &temp3;
52875 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52876 }
52877 if (obj3) {
52878 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52879 if (!SWIG_IsOK(res4)) {
52880 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52881 }
52882 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52883 }
52884 {
52885 PyThreadState* __tstate = wxPyBeginAllowThreads();
52886 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52887 wxPyEndAllowThreads(__tstate);
52888 if (PyErr_Occurred()) SWIG_fail;
52889 }
52890 {
52891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52892 }
52893 return resultobj;
52894 fail:
52895 return NULL;
52896 }
52897
52898
52899 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52900 PyObject *obj;
52901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52902 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52903 return SWIG_Py_Void();
52904 }
52905
52906 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52907 return SWIG_Python_InitShadowInstance(args);
52908 }
52909
52910 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52911 PyObject *resultobj = 0;
52912 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52913 wxRelationship arg2 ;
52914 wxWindow *arg3 = (wxWindow *) 0 ;
52915 wxEdge arg4 ;
52916 int arg5 = (int) 0 ;
52917 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52918 void *argp1 = 0 ;
52919 int res1 = 0 ;
52920 int val2 ;
52921 int ecode2 = 0 ;
52922 void *argp3 = 0 ;
52923 int res3 = 0 ;
52924 int val4 ;
52925 int ecode4 = 0 ;
52926 int val5 ;
52927 int ecode5 = 0 ;
52928 int val6 ;
52929 int ecode6 = 0 ;
52930 PyObject * obj0 = 0 ;
52931 PyObject * obj1 = 0 ;
52932 PyObject * obj2 = 0 ;
52933 PyObject * obj3 = 0 ;
52934 PyObject * obj4 = 0 ;
52935 PyObject * obj5 = 0 ;
52936 char * kwnames[] = {
52937 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52938 };
52939
52940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52942 if (!SWIG_IsOK(res1)) {
52943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52944 }
52945 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52946 ecode2 = SWIG_AsVal_int(obj1, &val2);
52947 if (!SWIG_IsOK(ecode2)) {
52948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52949 }
52950 arg2 = static_cast< wxRelationship >(val2);
52951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52952 if (!SWIG_IsOK(res3)) {
52953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52954 }
52955 arg3 = reinterpret_cast< wxWindow * >(argp3);
52956 ecode4 = SWIG_AsVal_int(obj3, &val4);
52957 if (!SWIG_IsOK(ecode4)) {
52958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52959 }
52960 arg4 = static_cast< wxEdge >(val4);
52961 if (obj4) {
52962 ecode5 = SWIG_AsVal_int(obj4, &val5);
52963 if (!SWIG_IsOK(ecode5)) {
52964 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52965 }
52966 arg5 = static_cast< int >(val5);
52967 }
52968 if (obj5) {
52969 ecode6 = SWIG_AsVal_int(obj5, &val6);
52970 if (!SWIG_IsOK(ecode6)) {
52971 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52972 }
52973 arg6 = static_cast< int >(val6);
52974 }
52975 {
52976 PyThreadState* __tstate = wxPyBeginAllowThreads();
52977 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52978 wxPyEndAllowThreads(__tstate);
52979 if (PyErr_Occurred()) SWIG_fail;
52980 }
52981 resultobj = SWIG_Py_Void();
52982 return resultobj;
52983 fail:
52984 return NULL;
52985 }
52986
52987
52988 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52989 PyObject *resultobj = 0;
52990 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52991 wxWindow *arg2 = (wxWindow *) 0 ;
52992 int arg3 = (int) 0 ;
52993 void *argp1 = 0 ;
52994 int res1 = 0 ;
52995 void *argp2 = 0 ;
52996 int res2 = 0 ;
52997 int val3 ;
52998 int ecode3 = 0 ;
52999 PyObject * obj0 = 0 ;
53000 PyObject * obj1 = 0 ;
53001 PyObject * obj2 = 0 ;
53002 char * kwnames[] = {
53003 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53004 };
53005
53006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53008 if (!SWIG_IsOK(res1)) {
53009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53010 }
53011 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53012 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53013 if (!SWIG_IsOK(res2)) {
53014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53015 }
53016 arg2 = reinterpret_cast< wxWindow * >(argp2);
53017 if (obj2) {
53018 ecode3 = SWIG_AsVal_int(obj2, &val3);
53019 if (!SWIG_IsOK(ecode3)) {
53020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53021 }
53022 arg3 = static_cast< int >(val3);
53023 }
53024 {
53025 PyThreadState* __tstate = wxPyBeginAllowThreads();
53026 (arg1)->LeftOf(arg2,arg3);
53027 wxPyEndAllowThreads(__tstate);
53028 if (PyErr_Occurred()) SWIG_fail;
53029 }
53030 resultobj = SWIG_Py_Void();
53031 return resultobj;
53032 fail:
53033 return NULL;
53034 }
53035
53036
53037 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53038 PyObject *resultobj = 0;
53039 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53040 wxWindow *arg2 = (wxWindow *) 0 ;
53041 int arg3 = (int) 0 ;
53042 void *argp1 = 0 ;
53043 int res1 = 0 ;
53044 void *argp2 = 0 ;
53045 int res2 = 0 ;
53046 int val3 ;
53047 int ecode3 = 0 ;
53048 PyObject * obj0 = 0 ;
53049 PyObject * obj1 = 0 ;
53050 PyObject * obj2 = 0 ;
53051 char * kwnames[] = {
53052 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53053 };
53054
53055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53057 if (!SWIG_IsOK(res1)) {
53058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53059 }
53060 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53062 if (!SWIG_IsOK(res2)) {
53063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53064 }
53065 arg2 = reinterpret_cast< wxWindow * >(argp2);
53066 if (obj2) {
53067 ecode3 = SWIG_AsVal_int(obj2, &val3);
53068 if (!SWIG_IsOK(ecode3)) {
53069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53070 }
53071 arg3 = static_cast< int >(val3);
53072 }
53073 {
53074 PyThreadState* __tstate = wxPyBeginAllowThreads();
53075 (arg1)->RightOf(arg2,arg3);
53076 wxPyEndAllowThreads(__tstate);
53077 if (PyErr_Occurred()) SWIG_fail;
53078 }
53079 resultobj = SWIG_Py_Void();
53080 return resultobj;
53081 fail:
53082 return NULL;
53083 }
53084
53085
53086 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53087 PyObject *resultobj = 0;
53088 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53089 wxWindow *arg2 = (wxWindow *) 0 ;
53090 int arg3 = (int) 0 ;
53091 void *argp1 = 0 ;
53092 int res1 = 0 ;
53093 void *argp2 = 0 ;
53094 int res2 = 0 ;
53095 int val3 ;
53096 int ecode3 = 0 ;
53097 PyObject * obj0 = 0 ;
53098 PyObject * obj1 = 0 ;
53099 PyObject * obj2 = 0 ;
53100 char * kwnames[] = {
53101 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53102 };
53103
53104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53106 if (!SWIG_IsOK(res1)) {
53107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53108 }
53109 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53111 if (!SWIG_IsOK(res2)) {
53112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53113 }
53114 arg2 = reinterpret_cast< wxWindow * >(argp2);
53115 if (obj2) {
53116 ecode3 = SWIG_AsVal_int(obj2, &val3);
53117 if (!SWIG_IsOK(ecode3)) {
53118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53119 }
53120 arg3 = static_cast< int >(val3);
53121 }
53122 {
53123 PyThreadState* __tstate = wxPyBeginAllowThreads();
53124 (arg1)->Above(arg2,arg3);
53125 wxPyEndAllowThreads(__tstate);
53126 if (PyErr_Occurred()) SWIG_fail;
53127 }
53128 resultobj = SWIG_Py_Void();
53129 return resultobj;
53130 fail:
53131 return NULL;
53132 }
53133
53134
53135 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53136 PyObject *resultobj = 0;
53137 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53138 wxWindow *arg2 = (wxWindow *) 0 ;
53139 int arg3 = (int) 0 ;
53140 void *argp1 = 0 ;
53141 int res1 = 0 ;
53142 void *argp2 = 0 ;
53143 int res2 = 0 ;
53144 int val3 ;
53145 int ecode3 = 0 ;
53146 PyObject * obj0 = 0 ;
53147 PyObject * obj1 = 0 ;
53148 PyObject * obj2 = 0 ;
53149 char * kwnames[] = {
53150 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53151 };
53152
53153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53155 if (!SWIG_IsOK(res1)) {
53156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53157 }
53158 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53159 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53160 if (!SWIG_IsOK(res2)) {
53161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53162 }
53163 arg2 = reinterpret_cast< wxWindow * >(argp2);
53164 if (obj2) {
53165 ecode3 = SWIG_AsVal_int(obj2, &val3);
53166 if (!SWIG_IsOK(ecode3)) {
53167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53168 }
53169 arg3 = static_cast< int >(val3);
53170 }
53171 {
53172 PyThreadState* __tstate = wxPyBeginAllowThreads();
53173 (arg1)->Below(arg2,arg3);
53174 wxPyEndAllowThreads(__tstate);
53175 if (PyErr_Occurred()) SWIG_fail;
53176 }
53177 resultobj = SWIG_Py_Void();
53178 return resultobj;
53179 fail:
53180 return NULL;
53181 }
53182
53183
53184 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53185 PyObject *resultobj = 0;
53186 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53187 wxWindow *arg2 = (wxWindow *) 0 ;
53188 wxEdge arg3 ;
53189 int arg4 = (int) 0 ;
53190 void *argp1 = 0 ;
53191 int res1 = 0 ;
53192 void *argp2 = 0 ;
53193 int res2 = 0 ;
53194 int val3 ;
53195 int ecode3 = 0 ;
53196 int val4 ;
53197 int ecode4 = 0 ;
53198 PyObject * obj0 = 0 ;
53199 PyObject * obj1 = 0 ;
53200 PyObject * obj2 = 0 ;
53201 PyObject * obj3 = 0 ;
53202 char * kwnames[] = {
53203 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53204 };
53205
53206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53208 if (!SWIG_IsOK(res1)) {
53209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53210 }
53211 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53213 if (!SWIG_IsOK(res2)) {
53214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53215 }
53216 arg2 = reinterpret_cast< wxWindow * >(argp2);
53217 ecode3 = SWIG_AsVal_int(obj2, &val3);
53218 if (!SWIG_IsOK(ecode3)) {
53219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53220 }
53221 arg3 = static_cast< wxEdge >(val3);
53222 if (obj3) {
53223 ecode4 = SWIG_AsVal_int(obj3, &val4);
53224 if (!SWIG_IsOK(ecode4)) {
53225 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53226 }
53227 arg4 = static_cast< int >(val4);
53228 }
53229 {
53230 PyThreadState* __tstate = wxPyBeginAllowThreads();
53231 (arg1)->SameAs(arg2,arg3,arg4);
53232 wxPyEndAllowThreads(__tstate);
53233 if (PyErr_Occurred()) SWIG_fail;
53234 }
53235 resultobj = SWIG_Py_Void();
53236 return resultobj;
53237 fail:
53238 return NULL;
53239 }
53240
53241
53242 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53243 PyObject *resultobj = 0;
53244 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53245 wxWindow *arg2 = (wxWindow *) 0 ;
53246 wxEdge arg3 ;
53247 int arg4 ;
53248 void *argp1 = 0 ;
53249 int res1 = 0 ;
53250 void *argp2 = 0 ;
53251 int res2 = 0 ;
53252 int val3 ;
53253 int ecode3 = 0 ;
53254 int val4 ;
53255 int ecode4 = 0 ;
53256 PyObject * obj0 = 0 ;
53257 PyObject * obj1 = 0 ;
53258 PyObject * obj2 = 0 ;
53259 PyObject * obj3 = 0 ;
53260 char * kwnames[] = {
53261 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53262 };
53263
53264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53266 if (!SWIG_IsOK(res1)) {
53267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53268 }
53269 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53271 if (!SWIG_IsOK(res2)) {
53272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53273 }
53274 arg2 = reinterpret_cast< wxWindow * >(argp2);
53275 ecode3 = SWIG_AsVal_int(obj2, &val3);
53276 if (!SWIG_IsOK(ecode3)) {
53277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53278 }
53279 arg3 = static_cast< wxEdge >(val3);
53280 ecode4 = SWIG_AsVal_int(obj3, &val4);
53281 if (!SWIG_IsOK(ecode4)) {
53282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53283 }
53284 arg4 = static_cast< int >(val4);
53285 {
53286 PyThreadState* __tstate = wxPyBeginAllowThreads();
53287 (arg1)->PercentOf(arg2,arg3,arg4);
53288 wxPyEndAllowThreads(__tstate);
53289 if (PyErr_Occurred()) SWIG_fail;
53290 }
53291 resultobj = SWIG_Py_Void();
53292 return resultobj;
53293 fail:
53294 return NULL;
53295 }
53296
53297
53298 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53299 PyObject *resultobj = 0;
53300 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53301 int arg2 ;
53302 void *argp1 = 0 ;
53303 int res1 = 0 ;
53304 int val2 ;
53305 int ecode2 = 0 ;
53306 PyObject * obj0 = 0 ;
53307 PyObject * obj1 = 0 ;
53308 char * kwnames[] = {
53309 (char *) "self",(char *) "val", NULL
53310 };
53311
53312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53314 if (!SWIG_IsOK(res1)) {
53315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53316 }
53317 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53318 ecode2 = SWIG_AsVal_int(obj1, &val2);
53319 if (!SWIG_IsOK(ecode2)) {
53320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53321 }
53322 arg2 = static_cast< int >(val2);
53323 {
53324 PyThreadState* __tstate = wxPyBeginAllowThreads();
53325 (arg1)->Absolute(arg2);
53326 wxPyEndAllowThreads(__tstate);
53327 if (PyErr_Occurred()) SWIG_fail;
53328 }
53329 resultobj = SWIG_Py_Void();
53330 return resultobj;
53331 fail:
53332 return NULL;
53333 }
53334
53335
53336 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53337 PyObject *resultobj = 0;
53338 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53339 void *argp1 = 0 ;
53340 int res1 = 0 ;
53341 PyObject *swig_obj[1] ;
53342
53343 if (!args) SWIG_fail;
53344 swig_obj[0] = args;
53345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53346 if (!SWIG_IsOK(res1)) {
53347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53348 }
53349 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53350 {
53351 PyThreadState* __tstate = wxPyBeginAllowThreads();
53352 (arg1)->Unconstrained();
53353 wxPyEndAllowThreads(__tstate);
53354 if (PyErr_Occurred()) SWIG_fail;
53355 }
53356 resultobj = SWIG_Py_Void();
53357 return resultobj;
53358 fail:
53359 return NULL;
53360 }
53361
53362
53363 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53364 PyObject *resultobj = 0;
53365 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53366 void *argp1 = 0 ;
53367 int res1 = 0 ;
53368 PyObject *swig_obj[1] ;
53369
53370 if (!args) SWIG_fail;
53371 swig_obj[0] = args;
53372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53373 if (!SWIG_IsOK(res1)) {
53374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53375 }
53376 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53377 {
53378 PyThreadState* __tstate = wxPyBeginAllowThreads();
53379 (arg1)->AsIs();
53380 wxPyEndAllowThreads(__tstate);
53381 if (PyErr_Occurred()) SWIG_fail;
53382 }
53383 resultobj = SWIG_Py_Void();
53384 return resultobj;
53385 fail:
53386 return NULL;
53387 }
53388
53389
53390 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53391 PyObject *resultobj = 0;
53392 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53393 wxWindow *result = 0 ;
53394 void *argp1 = 0 ;
53395 int res1 = 0 ;
53396 PyObject *swig_obj[1] ;
53397
53398 if (!args) SWIG_fail;
53399 swig_obj[0] = args;
53400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53401 if (!SWIG_IsOK(res1)) {
53402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53403 }
53404 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53405 {
53406 PyThreadState* __tstate = wxPyBeginAllowThreads();
53407 result = (wxWindow *)(arg1)->GetOtherWindow();
53408 wxPyEndAllowThreads(__tstate);
53409 if (PyErr_Occurred()) SWIG_fail;
53410 }
53411 {
53412 resultobj = wxPyMake_wxObject(result, 0);
53413 }
53414 return resultobj;
53415 fail:
53416 return NULL;
53417 }
53418
53419
53420 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53421 PyObject *resultobj = 0;
53422 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53423 wxEdge result;
53424 void *argp1 = 0 ;
53425 int res1 = 0 ;
53426 PyObject *swig_obj[1] ;
53427
53428 if (!args) SWIG_fail;
53429 swig_obj[0] = args;
53430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53431 if (!SWIG_IsOK(res1)) {
53432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53433 }
53434 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53435 {
53436 PyThreadState* __tstate = wxPyBeginAllowThreads();
53437 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53438 wxPyEndAllowThreads(__tstate);
53439 if (PyErr_Occurred()) SWIG_fail;
53440 }
53441 resultobj = SWIG_From_int(static_cast< int >(result));
53442 return resultobj;
53443 fail:
53444 return NULL;
53445 }
53446
53447
53448 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53449 PyObject *resultobj = 0;
53450 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53451 wxEdge arg2 ;
53452 void *argp1 = 0 ;
53453 int res1 = 0 ;
53454 int val2 ;
53455 int ecode2 = 0 ;
53456 PyObject * obj0 = 0 ;
53457 PyObject * obj1 = 0 ;
53458 char * kwnames[] = {
53459 (char *) "self",(char *) "which", NULL
53460 };
53461
53462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53464 if (!SWIG_IsOK(res1)) {
53465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53466 }
53467 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53468 ecode2 = SWIG_AsVal_int(obj1, &val2);
53469 if (!SWIG_IsOK(ecode2)) {
53470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53471 }
53472 arg2 = static_cast< wxEdge >(val2);
53473 {
53474 PyThreadState* __tstate = wxPyBeginAllowThreads();
53475 (arg1)->SetEdge(arg2);
53476 wxPyEndAllowThreads(__tstate);
53477 if (PyErr_Occurred()) SWIG_fail;
53478 }
53479 resultobj = SWIG_Py_Void();
53480 return resultobj;
53481 fail:
53482 return NULL;
53483 }
53484
53485
53486 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53487 PyObject *resultobj = 0;
53488 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53489 int arg2 ;
53490 void *argp1 = 0 ;
53491 int res1 = 0 ;
53492 int val2 ;
53493 int ecode2 = 0 ;
53494 PyObject * obj0 = 0 ;
53495 PyObject * obj1 = 0 ;
53496 char * kwnames[] = {
53497 (char *) "self",(char *) "v", NULL
53498 };
53499
53500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53502 if (!SWIG_IsOK(res1)) {
53503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53504 }
53505 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53506 ecode2 = SWIG_AsVal_int(obj1, &val2);
53507 if (!SWIG_IsOK(ecode2)) {
53508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53509 }
53510 arg2 = static_cast< int >(val2);
53511 {
53512 PyThreadState* __tstate = wxPyBeginAllowThreads();
53513 (arg1)->SetValue(arg2);
53514 wxPyEndAllowThreads(__tstate);
53515 if (PyErr_Occurred()) SWIG_fail;
53516 }
53517 resultobj = SWIG_Py_Void();
53518 return resultobj;
53519 fail:
53520 return NULL;
53521 }
53522
53523
53524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53525 PyObject *resultobj = 0;
53526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53527 int result;
53528 void *argp1 = 0 ;
53529 int res1 = 0 ;
53530 PyObject *swig_obj[1] ;
53531
53532 if (!args) SWIG_fail;
53533 swig_obj[0] = args;
53534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53535 if (!SWIG_IsOK(res1)) {
53536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53537 }
53538 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53539 {
53540 PyThreadState* __tstate = wxPyBeginAllowThreads();
53541 result = (int)(arg1)->GetMargin();
53542 wxPyEndAllowThreads(__tstate);
53543 if (PyErr_Occurred()) SWIG_fail;
53544 }
53545 resultobj = SWIG_From_int(static_cast< int >(result));
53546 return resultobj;
53547 fail:
53548 return NULL;
53549 }
53550
53551
53552 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53553 PyObject *resultobj = 0;
53554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53555 int arg2 ;
53556 void *argp1 = 0 ;
53557 int res1 = 0 ;
53558 int val2 ;
53559 int ecode2 = 0 ;
53560 PyObject * obj0 = 0 ;
53561 PyObject * obj1 = 0 ;
53562 char * kwnames[] = {
53563 (char *) "self",(char *) "m", NULL
53564 };
53565
53566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53568 if (!SWIG_IsOK(res1)) {
53569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53570 }
53571 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53572 ecode2 = SWIG_AsVal_int(obj1, &val2);
53573 if (!SWIG_IsOK(ecode2)) {
53574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53575 }
53576 arg2 = static_cast< int >(val2);
53577 {
53578 PyThreadState* __tstate = wxPyBeginAllowThreads();
53579 (arg1)->SetMargin(arg2);
53580 wxPyEndAllowThreads(__tstate);
53581 if (PyErr_Occurred()) SWIG_fail;
53582 }
53583 resultobj = SWIG_Py_Void();
53584 return resultobj;
53585 fail:
53586 return NULL;
53587 }
53588
53589
53590 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53591 PyObject *resultobj = 0;
53592 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53593 int result;
53594 void *argp1 = 0 ;
53595 int res1 = 0 ;
53596 PyObject *swig_obj[1] ;
53597
53598 if (!args) SWIG_fail;
53599 swig_obj[0] = args;
53600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53601 if (!SWIG_IsOK(res1)) {
53602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53603 }
53604 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53605 {
53606 PyThreadState* __tstate = wxPyBeginAllowThreads();
53607 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53608 wxPyEndAllowThreads(__tstate);
53609 if (PyErr_Occurred()) SWIG_fail;
53610 }
53611 resultobj = SWIG_From_int(static_cast< int >(result));
53612 return resultobj;
53613 fail:
53614 return NULL;
53615 }
53616
53617
53618 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53619 PyObject *resultobj = 0;
53620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53621 int result;
53622 void *argp1 = 0 ;
53623 int res1 = 0 ;
53624 PyObject *swig_obj[1] ;
53625
53626 if (!args) SWIG_fail;
53627 swig_obj[0] = args;
53628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53629 if (!SWIG_IsOK(res1)) {
53630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53631 }
53632 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53633 {
53634 PyThreadState* __tstate = wxPyBeginAllowThreads();
53635 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53636 wxPyEndAllowThreads(__tstate);
53637 if (PyErr_Occurred()) SWIG_fail;
53638 }
53639 resultobj = SWIG_From_int(static_cast< int >(result));
53640 return resultobj;
53641 fail:
53642 return NULL;
53643 }
53644
53645
53646 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53647 PyObject *resultobj = 0;
53648 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53649 int result;
53650 void *argp1 = 0 ;
53651 int res1 = 0 ;
53652 PyObject *swig_obj[1] ;
53653
53654 if (!args) SWIG_fail;
53655 swig_obj[0] = args;
53656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53657 if (!SWIG_IsOK(res1)) {
53658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53659 }
53660 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53661 {
53662 PyThreadState* __tstate = wxPyBeginAllowThreads();
53663 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53664 wxPyEndAllowThreads(__tstate);
53665 if (PyErr_Occurred()) SWIG_fail;
53666 }
53667 resultobj = SWIG_From_int(static_cast< int >(result));
53668 return resultobj;
53669 fail:
53670 return NULL;
53671 }
53672
53673
53674 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53675 PyObject *resultobj = 0;
53676 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53677 bool result;
53678 void *argp1 = 0 ;
53679 int res1 = 0 ;
53680 PyObject *swig_obj[1] ;
53681
53682 if (!args) SWIG_fail;
53683 swig_obj[0] = args;
53684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53685 if (!SWIG_IsOK(res1)) {
53686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53687 }
53688 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53689 {
53690 PyThreadState* __tstate = wxPyBeginAllowThreads();
53691 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53692 wxPyEndAllowThreads(__tstate);
53693 if (PyErr_Occurred()) SWIG_fail;
53694 }
53695 {
53696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53697 }
53698 return resultobj;
53699 fail:
53700 return NULL;
53701 }
53702
53703
53704 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53705 PyObject *resultobj = 0;
53706 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53707 bool arg2 ;
53708 void *argp1 = 0 ;
53709 int res1 = 0 ;
53710 bool val2 ;
53711 int ecode2 = 0 ;
53712 PyObject * obj0 = 0 ;
53713 PyObject * obj1 = 0 ;
53714 char * kwnames[] = {
53715 (char *) "self",(char *) "d", NULL
53716 };
53717
53718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53720 if (!SWIG_IsOK(res1)) {
53721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53722 }
53723 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53725 if (!SWIG_IsOK(ecode2)) {
53726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53727 }
53728 arg2 = static_cast< bool >(val2);
53729 {
53730 PyThreadState* __tstate = wxPyBeginAllowThreads();
53731 (arg1)->SetDone(arg2);
53732 wxPyEndAllowThreads(__tstate);
53733 if (PyErr_Occurred()) SWIG_fail;
53734 }
53735 resultobj = SWIG_Py_Void();
53736 return resultobj;
53737 fail:
53738 return NULL;
53739 }
53740
53741
53742 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53743 PyObject *resultobj = 0;
53744 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53745 wxRelationship result;
53746 void *argp1 = 0 ;
53747 int res1 = 0 ;
53748 PyObject *swig_obj[1] ;
53749
53750 if (!args) SWIG_fail;
53751 swig_obj[0] = args;
53752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53753 if (!SWIG_IsOK(res1)) {
53754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53755 }
53756 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53757 {
53758 PyThreadState* __tstate = wxPyBeginAllowThreads();
53759 result = (wxRelationship)(arg1)->GetRelationship();
53760 wxPyEndAllowThreads(__tstate);
53761 if (PyErr_Occurred()) SWIG_fail;
53762 }
53763 resultobj = SWIG_From_int(static_cast< int >(result));
53764 return resultobj;
53765 fail:
53766 return NULL;
53767 }
53768
53769
53770 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53771 PyObject *resultobj = 0;
53772 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53773 wxRelationship arg2 ;
53774 void *argp1 = 0 ;
53775 int res1 = 0 ;
53776 int val2 ;
53777 int ecode2 = 0 ;
53778 PyObject * obj0 = 0 ;
53779 PyObject * obj1 = 0 ;
53780 char * kwnames[] = {
53781 (char *) "self",(char *) "r", NULL
53782 };
53783
53784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53786 if (!SWIG_IsOK(res1)) {
53787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53788 }
53789 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53790 ecode2 = SWIG_AsVal_int(obj1, &val2);
53791 if (!SWIG_IsOK(ecode2)) {
53792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53793 }
53794 arg2 = static_cast< wxRelationship >(val2);
53795 {
53796 PyThreadState* __tstate = wxPyBeginAllowThreads();
53797 (arg1)->SetRelationship(arg2);
53798 wxPyEndAllowThreads(__tstate);
53799 if (PyErr_Occurred()) SWIG_fail;
53800 }
53801 resultobj = SWIG_Py_Void();
53802 return resultobj;
53803 fail:
53804 return NULL;
53805 }
53806
53807
53808 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53809 PyObject *resultobj = 0;
53810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53811 wxWindow *arg2 = (wxWindow *) 0 ;
53812 bool result;
53813 void *argp1 = 0 ;
53814 int res1 = 0 ;
53815 void *argp2 = 0 ;
53816 int res2 = 0 ;
53817 PyObject * obj0 = 0 ;
53818 PyObject * obj1 = 0 ;
53819 char * kwnames[] = {
53820 (char *) "self",(char *) "otherW", NULL
53821 };
53822
53823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53825 if (!SWIG_IsOK(res1)) {
53826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53827 }
53828 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53830 if (!SWIG_IsOK(res2)) {
53831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53832 }
53833 arg2 = reinterpret_cast< wxWindow * >(argp2);
53834 {
53835 PyThreadState* __tstate = wxPyBeginAllowThreads();
53836 result = (bool)(arg1)->ResetIfWin(arg2);
53837 wxPyEndAllowThreads(__tstate);
53838 if (PyErr_Occurred()) SWIG_fail;
53839 }
53840 {
53841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53842 }
53843 return resultobj;
53844 fail:
53845 return NULL;
53846 }
53847
53848
53849 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53850 PyObject *resultobj = 0;
53851 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53852 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53853 wxWindow *arg3 = (wxWindow *) 0 ;
53854 bool result;
53855 void *argp1 = 0 ;
53856 int res1 = 0 ;
53857 void *argp2 = 0 ;
53858 int res2 = 0 ;
53859 void *argp3 = 0 ;
53860 int res3 = 0 ;
53861 PyObject * obj0 = 0 ;
53862 PyObject * obj1 = 0 ;
53863 PyObject * obj2 = 0 ;
53864 char * kwnames[] = {
53865 (char *) "self",(char *) "constraints",(char *) "win", NULL
53866 };
53867
53868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53870 if (!SWIG_IsOK(res1)) {
53871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53872 }
53873 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53875 if (!SWIG_IsOK(res2)) {
53876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53877 }
53878 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53879 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53880 if (!SWIG_IsOK(res3)) {
53881 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53882 }
53883 arg3 = reinterpret_cast< wxWindow * >(argp3);
53884 {
53885 PyThreadState* __tstate = wxPyBeginAllowThreads();
53886 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53887 wxPyEndAllowThreads(__tstate);
53888 if (PyErr_Occurred()) SWIG_fail;
53889 }
53890 {
53891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53892 }
53893 return resultobj;
53894 fail:
53895 return NULL;
53896 }
53897
53898
53899 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53900 PyObject *resultobj = 0;
53901 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53902 wxEdge arg2 ;
53903 wxWindow *arg3 = (wxWindow *) 0 ;
53904 wxWindow *arg4 = (wxWindow *) 0 ;
53905 int result;
53906 void *argp1 = 0 ;
53907 int res1 = 0 ;
53908 int val2 ;
53909 int ecode2 = 0 ;
53910 void *argp3 = 0 ;
53911 int res3 = 0 ;
53912 void *argp4 = 0 ;
53913 int res4 = 0 ;
53914 PyObject * obj0 = 0 ;
53915 PyObject * obj1 = 0 ;
53916 PyObject * obj2 = 0 ;
53917 PyObject * obj3 = 0 ;
53918 char * kwnames[] = {
53919 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53920 };
53921
53922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53924 if (!SWIG_IsOK(res1)) {
53925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53926 }
53927 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53928 ecode2 = SWIG_AsVal_int(obj1, &val2);
53929 if (!SWIG_IsOK(ecode2)) {
53930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53931 }
53932 arg2 = static_cast< wxEdge >(val2);
53933 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53934 if (!SWIG_IsOK(res3)) {
53935 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53936 }
53937 arg3 = reinterpret_cast< wxWindow * >(argp3);
53938 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53939 if (!SWIG_IsOK(res4)) {
53940 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53941 }
53942 arg4 = reinterpret_cast< wxWindow * >(argp4);
53943 {
53944 PyThreadState* __tstate = wxPyBeginAllowThreads();
53945 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53946 wxPyEndAllowThreads(__tstate);
53947 if (PyErr_Occurred()) SWIG_fail;
53948 }
53949 resultobj = SWIG_From_int(static_cast< int >(result));
53950 return resultobj;
53951 fail:
53952 return NULL;
53953 }
53954
53955
53956 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53957 PyObject *obj;
53958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53959 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53960 return SWIG_Py_Void();
53961 }
53962
53963 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53964 PyObject *resultobj = 0;
53965 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53966 wxIndividualLayoutConstraint *result = 0 ;
53967 void *argp1 = 0 ;
53968 int res1 = 0 ;
53969 PyObject *swig_obj[1] ;
53970
53971 if (!args) SWIG_fail;
53972 swig_obj[0] = args;
53973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53974 if (!SWIG_IsOK(res1)) {
53975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53976 }
53977 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53978 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53980 return resultobj;
53981 fail:
53982 return NULL;
53983 }
53984
53985
53986 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53987 PyObject *resultobj = 0;
53988 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53989 wxIndividualLayoutConstraint *result = 0 ;
53990 void *argp1 = 0 ;
53991 int res1 = 0 ;
53992 PyObject *swig_obj[1] ;
53993
53994 if (!args) SWIG_fail;
53995 swig_obj[0] = args;
53996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53997 if (!SWIG_IsOK(res1)) {
53998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53999 }
54000 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54001 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54003 return resultobj;
54004 fail:
54005 return NULL;
54006 }
54007
54008
54009 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54010 PyObject *resultobj = 0;
54011 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54012 wxIndividualLayoutConstraint *result = 0 ;
54013 void *argp1 = 0 ;
54014 int res1 = 0 ;
54015 PyObject *swig_obj[1] ;
54016
54017 if (!args) SWIG_fail;
54018 swig_obj[0] = args;
54019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54020 if (!SWIG_IsOK(res1)) {
54021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54022 }
54023 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54024 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54026 return resultobj;
54027 fail:
54028 return NULL;
54029 }
54030
54031
54032 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54033 PyObject *resultobj = 0;
54034 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54035 wxIndividualLayoutConstraint *result = 0 ;
54036 void *argp1 = 0 ;
54037 int res1 = 0 ;
54038 PyObject *swig_obj[1] ;
54039
54040 if (!args) SWIG_fail;
54041 swig_obj[0] = args;
54042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54043 if (!SWIG_IsOK(res1)) {
54044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54045 }
54046 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54047 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54049 return resultobj;
54050 fail:
54051 return NULL;
54052 }
54053
54054
54055 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54056 PyObject *resultobj = 0;
54057 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54058 wxIndividualLayoutConstraint *result = 0 ;
54059 void *argp1 = 0 ;
54060 int res1 = 0 ;
54061 PyObject *swig_obj[1] ;
54062
54063 if (!args) SWIG_fail;
54064 swig_obj[0] = args;
54065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54066 if (!SWIG_IsOK(res1)) {
54067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54068 }
54069 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54070 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54072 return resultobj;
54073 fail:
54074 return NULL;
54075 }
54076
54077
54078 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54079 PyObject *resultobj = 0;
54080 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54081 wxIndividualLayoutConstraint *result = 0 ;
54082 void *argp1 = 0 ;
54083 int res1 = 0 ;
54084 PyObject *swig_obj[1] ;
54085
54086 if (!args) SWIG_fail;
54087 swig_obj[0] = args;
54088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54089 if (!SWIG_IsOK(res1)) {
54090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54091 }
54092 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54093 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54095 return resultobj;
54096 fail:
54097 return NULL;
54098 }
54099
54100
54101 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54102 PyObject *resultobj = 0;
54103 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54104 wxIndividualLayoutConstraint *result = 0 ;
54105 void *argp1 = 0 ;
54106 int res1 = 0 ;
54107 PyObject *swig_obj[1] ;
54108
54109 if (!args) SWIG_fail;
54110 swig_obj[0] = args;
54111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54112 if (!SWIG_IsOK(res1)) {
54113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54114 }
54115 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54116 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54118 return resultobj;
54119 fail:
54120 return NULL;
54121 }
54122
54123
54124 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54125 PyObject *resultobj = 0;
54126 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54127 wxIndividualLayoutConstraint *result = 0 ;
54128 void *argp1 = 0 ;
54129 int res1 = 0 ;
54130 PyObject *swig_obj[1] ;
54131
54132 if (!args) SWIG_fail;
54133 swig_obj[0] = args;
54134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54135 if (!SWIG_IsOK(res1)) {
54136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54137 }
54138 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54139 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54141 return resultobj;
54142 fail:
54143 return NULL;
54144 }
54145
54146
54147 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54148 PyObject *resultobj = 0;
54149 wxLayoutConstraints *result = 0 ;
54150
54151 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54152 {
54153 PyThreadState* __tstate = wxPyBeginAllowThreads();
54154 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54155 wxPyEndAllowThreads(__tstate);
54156 if (PyErr_Occurred()) SWIG_fail;
54157 }
54158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54159 return resultobj;
54160 fail:
54161 return NULL;
54162 }
54163
54164
54165 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54166 PyObject *resultobj = 0;
54167 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54168 void *argp1 = 0 ;
54169 int res1 = 0 ;
54170 PyObject *swig_obj[1] ;
54171
54172 if (!args) SWIG_fail;
54173 swig_obj[0] = args;
54174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54175 if (!SWIG_IsOK(res1)) {
54176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54177 }
54178 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54179 {
54180 PyThreadState* __tstate = wxPyBeginAllowThreads();
54181 delete arg1;
54182
54183 wxPyEndAllowThreads(__tstate);
54184 if (PyErr_Occurred()) SWIG_fail;
54185 }
54186 resultobj = SWIG_Py_Void();
54187 return resultobj;
54188 fail:
54189 return NULL;
54190 }
54191
54192
54193 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54194 PyObject *resultobj = 0;
54195 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54196 wxWindow *arg2 = (wxWindow *) 0 ;
54197 int *arg3 = (int *) 0 ;
54198 bool result;
54199 void *argp1 = 0 ;
54200 int res1 = 0 ;
54201 void *argp2 = 0 ;
54202 int res2 = 0 ;
54203 int temp3 ;
54204 int res3 = SWIG_TMPOBJ ;
54205 PyObject * obj0 = 0 ;
54206 PyObject * obj1 = 0 ;
54207 char * kwnames[] = {
54208 (char *) "self",(char *) "win", NULL
54209 };
54210
54211 arg3 = &temp3;
54212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54214 if (!SWIG_IsOK(res1)) {
54215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54216 }
54217 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54219 if (!SWIG_IsOK(res2)) {
54220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54221 }
54222 arg2 = reinterpret_cast< wxWindow * >(argp2);
54223 {
54224 PyThreadState* __tstate = wxPyBeginAllowThreads();
54225 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54226 wxPyEndAllowThreads(__tstate);
54227 if (PyErr_Occurred()) SWIG_fail;
54228 }
54229 {
54230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54231 }
54232 if (SWIG_IsTmpObj(res3)) {
54233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54234 } else {
54235 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54237 }
54238 return resultobj;
54239 fail:
54240 return NULL;
54241 }
54242
54243
54244 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54245 PyObject *resultobj = 0;
54246 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54247 bool result;
54248 void *argp1 = 0 ;
54249 int res1 = 0 ;
54250 PyObject *swig_obj[1] ;
54251
54252 if (!args) SWIG_fail;
54253 swig_obj[0] = args;
54254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54255 if (!SWIG_IsOK(res1)) {
54256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54257 }
54258 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54259 {
54260 PyThreadState* __tstate = wxPyBeginAllowThreads();
54261 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54262 wxPyEndAllowThreads(__tstate);
54263 if (PyErr_Occurred()) SWIG_fail;
54264 }
54265 {
54266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54267 }
54268 return resultobj;
54269 fail:
54270 return NULL;
54271 }
54272
54273
54274 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54275 PyObject *obj;
54276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54277 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54278 return SWIG_Py_Void();
54279 }
54280
54281 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54282 return SWIG_Python_InitShadowInstance(args);
54283 }
54284
54285 static PyMethodDef SwigMethods[] = {
54286 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54287 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54288 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54289 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54290 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54291 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54292 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54293 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54294 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54295 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54296 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54309 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54310 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54311 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54313 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54314 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54315 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54316 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54317 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54318 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54319 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54321 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54325 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54327 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54328 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54329 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54330 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54331 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54332 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54333 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54335 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54343 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54344 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54345 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54350 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54351 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54353 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54355 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54357 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54359 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54361 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54363 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54364 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54366 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54368 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54369 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54370 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54372 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54373 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54374 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54375 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54395 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54396 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54397 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54398 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54399 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54400 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54401 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54402 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54404 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54405 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54406 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54411 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54412 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54413 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54414 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54415 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54422 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54429 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54430 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54431 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54432 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54434 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54435 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54436 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54438 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54439 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54440 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54441 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54446 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54447 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54448 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54449 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54450 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54451 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54454 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54455 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54456 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54458 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54459 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54461 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54462 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54463 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54464 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54465 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54466 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54467 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54468 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54469 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54470 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54471 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54472 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54477 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54483 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54484 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54485 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54486 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54488 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54491 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54494 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54497 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54498 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54499 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54502 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54503 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54504 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54508 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54509 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54510 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54514 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54518 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54519 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54520 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54521 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54522 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54523 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54524 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54525 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54529 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54530 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54531 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54532 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54533 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54534 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54535 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54536 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54537 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54543 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54544 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54546 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54547 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54548 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54549 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54550 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54551 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54552 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54553 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54554 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54555 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54556 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54557 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54558 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54559 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54560 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54561 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54562 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54563 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54564 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54565 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54568 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54569 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54572 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54573 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54590 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54591 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54606 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54607 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54608 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54609 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54612 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54614 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54616 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54618 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54620 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54621 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54623 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54624 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54625 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54626 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54628 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54640 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54645 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54646 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54652 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54653 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54655 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54656 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54657 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54658 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54659 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54660 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54661 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54662 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54663 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54664 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54665 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54666 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54667 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54668 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54669 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54670 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54671 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54672 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54673 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54674 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54675 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54676 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54677 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54678 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54679 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54680 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54681 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54682 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54683 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54684 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54685 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54686 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54687 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54688 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54689 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54690 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54691 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54692 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54695 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54699 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54700 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54701 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54702 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54706 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54707 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54708 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54709 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54711 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54712 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54713 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54714 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54715 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54716 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54717 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54718 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54720 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54721 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54722 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54724 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54725 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54727 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54728 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54729 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54731 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54732 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54733 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54735 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54737 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54738 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54739 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54741 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54742 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54743 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54744 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54746 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54747 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54748 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54750 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54751 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54752 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54753 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54754 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54756 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54757 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54760 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54761 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54763 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54764 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54767 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54768 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54770 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54776 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54777 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54778 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54779 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54780 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54781 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54782 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54783 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54784 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54785 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54786 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54787 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54788 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54789 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54790 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54791 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54792 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54793 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54794 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54795 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54796 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54797 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54798 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54799 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54801 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54802 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54803 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54804 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54805 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54806 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54807 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54808 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54809 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54810 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54811 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54812 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54813 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54814 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54815 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54816 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54817 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54818 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54819 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54820 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54821 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54822 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54823 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54824 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54825 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54826 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54827 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54828 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54829 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54830 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54831 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54832 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54834 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54835 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54837 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54838 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54839 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54840 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54842 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54843 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54844 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54845 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54846 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54847 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54848 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54849 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54850 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54852 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54853 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54854 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54855 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54856 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54857 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54858 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54859 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54860 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54861 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54862 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54863 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54864 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54865 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54866 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54867 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54868 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54869 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54870 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54871 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54872 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54873 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54874 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54875 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54876 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54877 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54878 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54879 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54881 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54882 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54885 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54886 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54887 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54888 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54889 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54890 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54892 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54893 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54896 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54897 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54899 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54900 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54902 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54903 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54905 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54906 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54907 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54909 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54911 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54912 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54914 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54915 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54916 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54918 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54919 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54920 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54922 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54923 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54924 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54925 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54926 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54927 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54928 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54929 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54932 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54934 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54935 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54936 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54937 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54938 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54941 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54942 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54943 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54944 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54945 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54946 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54947 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54949 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54950 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54951 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54952 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54953 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54954 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54955 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54956 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54957 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54958 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54959 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54960 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54961 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54962 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54963 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54969 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54971 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54973 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54974 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54975 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54976 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54977 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54978 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54980 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54981 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54982 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54984 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54985 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54986 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54987 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54988 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54991 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54992 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54993 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54996 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54997 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54998 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54999 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55000 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55002 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55004 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55007 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55009 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55010 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55012 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55013 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55014 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55016 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55017 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55018 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55020 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55022 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55023 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55024 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55026 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55028 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55030 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55031 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55033 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55034 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55036 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55038 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55039 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55040 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55042 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55044 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55045 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55046 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55048 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55050 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55051 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55052 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55053 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55054 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55055 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55057 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55059 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55061 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55062 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55064 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55065 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55066 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55067 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55068 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55069 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55070 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55071 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55072 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55074 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55076 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55077 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55078 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55079 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55080 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55082 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55084 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55085 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55086 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55087 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55088 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55089 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55095 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55096 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55097 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55098 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55099 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55100 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55101 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55102 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55104 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55105 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55106 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55107 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55109 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55110 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55111 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55112 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55114 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55115 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55116 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55117 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55119 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55120 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55122 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55123 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55124 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55126 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55129 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55130 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55131 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55132 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55133 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55135 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55136 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55138 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55139 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55140 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55141 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55142 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55143 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55144 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55145 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55146 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55147 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55148 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55149 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55150 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55151 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55152 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55154 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55155 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55157 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55158 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55159 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55161 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55163 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55164 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55165 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55167 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55168 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55171 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55173 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55174 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55181 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55182 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55186 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55187 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55188 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55189 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55190 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55191 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55192 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55193 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55194 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55195 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55196 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55197 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55198 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55199 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55200 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55201 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55202 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55203 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55206 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55207 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55212 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55213 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55216 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55217 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55218 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55219 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55220 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55222 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55223 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55224 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55225 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55226 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55227 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55228 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55229 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55230 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55231 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55232 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55233 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55234 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55235 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55236 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55237 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55238 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55239 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55240 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55241 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55242 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55243 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55244 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55245 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55247 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55248 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55249 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55250 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55251 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55252 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55254 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55255 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55259 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55262 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55263 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55265 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55266 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55267 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55268 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55269 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55270 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55271 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55275 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55276 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55277 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55278 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55281 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55282 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55283 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55284 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55287 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55288 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55289 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55290 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55291 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55293 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55294 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55295 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55296 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55297 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55299 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55300 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55305 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55306 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55307 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55308 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55310 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55311 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55313 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55314 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55315 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55316 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55317 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55318 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55319 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55320 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55323 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55325 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55326 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55329 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55333 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55334 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55335 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55336 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55339 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55340 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55342 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55343 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55345 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55346 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55347 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55348 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55349 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55353 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55354 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55355 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55356 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55358 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55359 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55361 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55362 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55363 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55364 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55365 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55366 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55367 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55368 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55369 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55370 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55371 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55372 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55373 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55374 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55375 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55376 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55377 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55378 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55379 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55380 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55381 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55382 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55383 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55384 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55385 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55386 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55387 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55388 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55389 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55390 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55391 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55392 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55394 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55395 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55396 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55397 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55398 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55399 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55400 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55401 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55402 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55403 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55404 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55405 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55406 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55407 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55408 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55411 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55412 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55413 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55414 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55415 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55416 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55417 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55420 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55421 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55422 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55423 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55424 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55425 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55426 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55427 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55431 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55432 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55434 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55438 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55440 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55442 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55443 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55445 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55446 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55447 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55448 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55449 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55450 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55451 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55452 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55453 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55454 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55455 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55456 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55457 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55458 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55475 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55476 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55477 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55478 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55479 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55480 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55481 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55482 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55483 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55484 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55485 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55486 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55487 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55488 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55489 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55490 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55491 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55492 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55493 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55495 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55496 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55498 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55499 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55500 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55501 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55502 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55503 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55504 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55505 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55506 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55508 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55509 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55510 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55511 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55512 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55513 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55514 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55515 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55516 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55517 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55518 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55519 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55521 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55522 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55523 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55524 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55525 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55526 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55527 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55528 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55529 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55530 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55531 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55532 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55533 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55534 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55535 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55536 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55537 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55538 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55539 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55540 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55541 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55542 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55543 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55544 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55545 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55546 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55547 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55548 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55549 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55550 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55551 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55552 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55553 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55554 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55555 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55556 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55557 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55558 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55559 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55560 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55561 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55562 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55563 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55564 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55565 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55566 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55567 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55569 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55570 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55571 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55573 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55574 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55575 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55576 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55577 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55578 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55579 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55580 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55581 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55582 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55583 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55584 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55585 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55586 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55587 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55588 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55589 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55590 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55591 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55592 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55593 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55594 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55595 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55596 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55597 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55598 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55599 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55600 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55602 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55603 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55604 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55605 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55606 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55607 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55608 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55609 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55612 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55613 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55614 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55615 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55616 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55617 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55618 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55619 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55620 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55621 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55622 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55623 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55624 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55625 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55626 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55627 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55628 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55629 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55630 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55631 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55632 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55633 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55634 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55635 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55636 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55637 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55638 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55639 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55640 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55641 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55642 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55643 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55644 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55645 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55646 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55647 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55648 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55649 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55650 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55651 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55652 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55653 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55654 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55655 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55656 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55657 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55658 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55659 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55660 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55661 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55662 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55663 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55664 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55665 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55666 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55667 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55668 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55669 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55670 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55671 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55672 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55673 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55674 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55675 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55676 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55677 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55678 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55679 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55680 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55681 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55682 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55683 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55684 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55685 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55686 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55687 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55688 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55689 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55690 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55691 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55692 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55693 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55694 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55695 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55696 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55697 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55698 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55699 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55700 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55701 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55702 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55703 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55704 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55705 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55706 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55707 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55708 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55709 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55710 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55711 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55712 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55713 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55714 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55715 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55716 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55717 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55718 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55719 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55720 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55721 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55722 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55723 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55724 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55725 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55726 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55727 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55728 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55729 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55730 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55731 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55732 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55733 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55734 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55735 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55736 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55737 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55738 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55739 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55740 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55741 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55742 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55743 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55744 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55745 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55746 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55747 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55748 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55750 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55751 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55752 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55753 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55754 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55756 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55757 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55758 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55759 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55760 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55761 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55762 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55763 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55764 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55765 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55766 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55767 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55768 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55769 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55770 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55771 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55772 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55773 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55774 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55775 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55776 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55777 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55778 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55779 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55780 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55781 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55782 { NULL, NULL, 0, NULL }
55783 };
55784
55785
55786 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55787
55788 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55789 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55790 }
55791 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55792 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55793 }
55794 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55795 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55796 }
55797 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55798 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55799 }
55800 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55801 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55802 }
55803 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55804 return (void *)((wxSizer *) ((wxGridSizer *) x));
55805 }
55806 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55807 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55808 }
55809 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55810 return (void *)((wxSizer *) ((wxPySizer *) x));
55811 }
55812 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55813 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55814 }
55815 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55816 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55817 }
55818 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55819 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55820 }
55821 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55822 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55823 }
55824 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55825 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55826 }
55827 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55828 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55829 }
55830 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55831 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55832 }
55833 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55834 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55835 }
55836 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55837 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55838 }
55839 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55840 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55841 }
55842 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55843 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55844 }
55845 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55846 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55847 }
55848 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55849 return (void *)((wxEvent *) ((wxPyEvent *) x));
55850 }
55851 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55852 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55853 }
55854 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55855 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55856 }
55857 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55858 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55859 }
55860 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55861 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55862 }
55863 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55864 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55865 }
55866 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55867 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55868 }
55869 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55870 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55871 }
55872 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55873 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55874 }
55875 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55876 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55877 }
55878 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55879 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55880 }
55881 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55882 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55883 }
55884 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55885 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55886 }
55887 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55888 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55889 }
55890 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55891 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55892 }
55893 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55894 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55895 }
55896 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55897 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55898 }
55899 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55900 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55901 }
55902 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55903 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55904 }
55905 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55906 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55907 }
55908 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55909 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55910 }
55911 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55912 return (void *)((wxEvent *) ((wxShowEvent *) x));
55913 }
55914 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55915 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55916 }
55917 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55918 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55919 }
55920 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55921 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55922 }
55923 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55924 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55925 }
55926 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55927 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55928 }
55929 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55930 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55931 }
55932 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55933 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55934 }
55935 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55936 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55937 }
55938 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55939 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55940 }
55941 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55942 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55943 }
55944 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55945 return (void *)((wxControl *) ((wxControlWithItems *) x));
55946 }
55947 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55948 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55949 }
55950 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55951 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55952 }
55953 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55954 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55955 }
55956 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55957 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55958 }
55959 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55960 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55961 }
55962 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55963 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55964 }
55965 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55966 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55967 }
55968 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55969 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55970 }
55971 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55972 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55973 }
55974 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55975 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55976 }
55977 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55978 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55979 }
55980 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55981 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55982 }
55983 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55984 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55985 }
55986 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55987 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55988 }
55989 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55990 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55991 }
55992 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55993 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55994 }
55995 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55996 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55997 }
55998 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55999 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56000 }
56001 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56002 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56003 }
56004 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56005 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56006 }
56007 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56008 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56009 }
56010 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56011 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56012 }
56013 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56014 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56015 }
56016 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56017 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56018 }
56019 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56020 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56021 }
56022 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56023 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56024 }
56025 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56026 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56027 }
56028 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56029 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56030 }
56031 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56032 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56033 }
56034 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56035 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56036 }
56037 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56038 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56039 }
56040 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56041 return (void *)((wxObject *) ((wxSizerItem *) x));
56042 }
56043 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56044 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56045 }
56046 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56047 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56048 }
56049 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56050 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56051 }
56052 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56053 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56054 }
56055 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56056 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56057 }
56058 static void *_p_wxSizerTo_p_wxObject(void *x) {
56059 return (void *)((wxObject *) ((wxSizer *) x));
56060 }
56061 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56062 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56063 }
56064 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56065 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56066 }
56067 static void *_p_wxEventTo_p_wxObject(void *x) {
56068 return (void *)((wxObject *) ((wxEvent *) x));
56069 }
56070 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56071 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56072 }
56073 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56074 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56075 }
56076 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56077 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56078 }
56079 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56080 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56081 }
56082 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56083 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56084 }
56085 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56086 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56087 }
56088 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56089 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56090 }
56091 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56092 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56093 }
56094 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56095 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56096 }
56097 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56098 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56099 }
56100 static void *_p_wxControlTo_p_wxObject(void *x) {
56101 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56102 }
56103 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56104 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56105 }
56106 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56107 return (void *)((wxObject *) ((wxFSFile *) x));
56108 }
56109 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56110 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56111 }
56112 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56113 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56114 }
56115 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56117 }
56118 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56119 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56120 }
56121 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56122 return (void *)((wxObject *) ((wxMenuItem *) x));
56123 }
56124 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56125 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56126 }
56127 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56128 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56129 }
56130 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56131 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56132 }
56133 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56134 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56135 }
56136 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56137 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56138 }
56139 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56140 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56141 }
56142 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56143 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56144 }
56145 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56146 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56147 }
56148 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56149 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56150 }
56151 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56152 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56153 }
56154 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56155 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56156 }
56157 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56158 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56159 }
56160 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56161 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56162 }
56163 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56164 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56165 }
56166 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56167 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56168 }
56169 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56170 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56171 }
56172 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56173 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56174 }
56175 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56176 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56177 }
56178 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56179 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56180 }
56181 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56182 return (void *)((wxObject *) ((wxImageHandler *) x));
56183 }
56184 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56185 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56186 }
56187 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56188 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56189 }
56190 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56191 return (void *)((wxObject *) ((wxEvtHandler *) x));
56192 }
56193 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56194 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56195 }
56196 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56197 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56198 }
56199 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56200 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56201 }
56202 static void *_p_wxImageTo_p_wxObject(void *x) {
56203 return (void *)((wxObject *) ((wxImage *) x));
56204 }
56205 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56206 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56207 }
56208 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56209 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56210 }
56211 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56212 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56213 }
56214 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56215 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56216 }
56217 static void *_p_wxWindowTo_p_wxObject(void *x) {
56218 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56219 }
56220 static void *_p_wxMenuTo_p_wxObject(void *x) {
56221 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56222 }
56223 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56224 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56225 }
56226 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56227 return (void *)((wxObject *) ((wxFileSystem *) x));
56228 }
56229 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56230 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56231 }
56232 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56233 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56234 }
56235 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56236 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56237 }
56238 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56239 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56240 }
56241 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56242 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56243 }
56244 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56245 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56246 }
56247 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56248 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56249 }
56250 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56251 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56252 }
56253 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56254 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56255 }
56256 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56257 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56258 }
56259 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56260 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56261 }
56262 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56263 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56264 }
56265 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56266 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56267 }
56268 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56269 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56270 }
56271 static void *_p_wxControlTo_p_wxWindow(void *x) {
56272 return (void *)((wxWindow *) ((wxControl *) x));
56273 }
56274 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56275 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56276 }
56277 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56278 return (void *)((wxWindow *) ((wxMenuBar *) x));
56279 }
56280 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56281 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56282 }
56283 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56284 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56285 }
56286 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56287 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56288 }
56289 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56290 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56291 }
56292 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56293 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56294 }
56295 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56296 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56297 }
56298 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56299 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56300 }
56301 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56302 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56303 }
56304 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56305 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56306 }
56307 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56308 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56309 }
56310 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56311 return (void *)((wxValidator *) ((wxPyValidator *) x));
56312 }
56313 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56314 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56315 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};
56316 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56317 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56318 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56319 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56320 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56321 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56322 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56323 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56324 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56325 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56326 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56327 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56328 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56329 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56330 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56331 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56332 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56333 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56334 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56335 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56336 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56337 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56338 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56339 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56340 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56341 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56342 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56343 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56344 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56345 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56346 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56347 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56348 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56349 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56351 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56352 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56445
56446 static swig_type_info *swig_type_initial[] = {
56447 &_swigt__p_buffer,
56448 &_swigt__p_char,
56449 &_swigt__p_form_ops_t,
56450 &_swigt__p_int,
56451 &_swigt__p_long,
56452 &_swigt__p_unsigned_char,
56453 &_swigt__p_unsigned_int,
56454 &_swigt__p_unsigned_long,
56455 &_swigt__p_wxANIHandler,
56456 &_swigt__p_wxAcceleratorEntry,
56457 &_swigt__p_wxAcceleratorTable,
56458 &_swigt__p_wxActivateEvent,
56459 &_swigt__p_wxAppTraits,
56460 &_swigt__p_wxArrayString,
56461 &_swigt__p_wxBMPHandler,
56462 &_swigt__p_wxBitmap,
56463 &_swigt__p_wxBoxSizer,
56464 &_swigt__p_wxButton,
56465 &_swigt__p_wxCURHandler,
56466 &_swigt__p_wxCaret,
56467 &_swigt__p_wxChildFocusEvent,
56468 &_swigt__p_wxClipboardTextEvent,
56469 &_swigt__p_wxCloseEvent,
56470 &_swigt__p_wxColour,
56471 &_swigt__p_wxCommandEvent,
56472 &_swigt__p_wxContextMenuEvent,
56473 &_swigt__p_wxControl,
56474 &_swigt__p_wxControlWithItems,
56475 &_swigt__p_wxCursor,
56476 &_swigt__p_wxDC,
56477 &_swigt__p_wxDateEvent,
56478 &_swigt__p_wxDateTime,
56479 &_swigt__p_wxDisplayChangedEvent,
56480 &_swigt__p_wxDropFilesEvent,
56481 &_swigt__p_wxDuplexMode,
56482 &_swigt__p_wxEraseEvent,
56483 &_swigt__p_wxEvent,
56484 &_swigt__p_wxEventLoop,
56485 &_swigt__p_wxEventLoopActivator,
56486 &_swigt__p_wxEvtHandler,
56487 &_swigt__p_wxFSFile,
56488 &_swigt__p_wxFileSystem,
56489 &_swigt__p_wxFileSystemHandler,
56490 &_swigt__p_wxFlexGridSizer,
56491 &_swigt__p_wxFocusEvent,
56492 &_swigt__p_wxFont,
56493 &_swigt__p_wxFrame,
56494 &_swigt__p_wxGBPosition,
56495 &_swigt__p_wxGBSizerItem,
56496 &_swigt__p_wxGBSpan,
56497 &_swigt__p_wxGIFHandler,
56498 &_swigt__p_wxGridBagSizer,
56499 &_swigt__p_wxGridSizer,
56500 &_swigt__p_wxHelpEvent__Origin,
56501 &_swigt__p_wxICOHandler,
56502 &_swigt__p_wxIconizeEvent,
56503 &_swigt__p_wxIdleEvent,
56504 &_swigt__p_wxImage,
56505 &_swigt__p_wxImageHandler,
56506 &_swigt__p_wxImageHistogram,
56507 &_swigt__p_wxImage_HSVValue,
56508 &_swigt__p_wxImage_RGBValue,
56509 &_swigt__p_wxIndividualLayoutConstraint,
56510 &_swigt__p_wxInitDialogEvent,
56511 &_swigt__p_wxInputStream,
56512 &_swigt__p_wxInternetFSHandler,
56513 &_swigt__p_wxItemContainer,
56514 &_swigt__p_wxJPEGHandler,
56515 &_swigt__p_wxKeyEvent,
56516 &_swigt__p_wxLayoutConstraints,
56517 &_swigt__p_wxMaximizeEvent,
56518 &_swigt__p_wxMemoryFSHandler,
56519 &_swigt__p_wxMenu,
56520 &_swigt__p_wxMenuBar,
56521 &_swigt__p_wxMenuBarBase,
56522 &_swigt__p_wxMenuEvent,
56523 &_swigt__p_wxMenuItem,
56524 &_swigt__p_wxMouseCaptureChangedEvent,
56525 &_swigt__p_wxMouseCaptureLostEvent,
56526 &_swigt__p_wxMouseEvent,
56527 &_swigt__p_wxMoveEvent,
56528 &_swigt__p_wxNavigationKeyEvent,
56529 &_swigt__p_wxNcPaintEvent,
56530 &_swigt__p_wxNotifyEvent,
56531 &_swigt__p_wxObject,
56532 &_swigt__p_wxOutputStream,
56533 &_swigt__p_wxPCXHandler,
56534 &_swigt__p_wxPNGHandler,
56535 &_swigt__p_wxPNMHandler,
56536 &_swigt__p_wxPaintEvent,
56537 &_swigt__p_wxPaletteChangedEvent,
56538 &_swigt__p_wxPaperSize,
56539 &_swigt__p_wxPoint,
56540 &_swigt__p_wxPoint2D,
56541 &_swigt__p_wxPropagateOnce,
56542 &_swigt__p_wxPropagationDisabler,
56543 &_swigt__p_wxPyApp,
56544 &_swigt__p_wxPyCommandEvent,
56545 &_swigt__p_wxPyDropTarget,
56546 &_swigt__p_wxPyEvent,
56547 &_swigt__p_wxPyFileSystemHandler,
56548 &_swigt__p_wxPyImageHandler,
56549 &_swigt__p_wxPyInputStream,
56550 &_swigt__p_wxPySizer,
56551 &_swigt__p_wxPyValidator,
56552 &_swigt__p_wxQuantize,
56553 &_swigt__p_wxQueryNewPaletteEvent,
56554 &_swigt__p_wxRealPoint,
56555 &_swigt__p_wxRect,
56556 &_swigt__p_wxRegion,
56557 &_swigt__p_wxScrollEvent,
56558 &_swigt__p_wxScrollWinEvent,
56559 &_swigt__p_wxSetCursorEvent,
56560 &_swigt__p_wxShowEvent,
56561 &_swigt__p_wxSize,
56562 &_swigt__p_wxSizeEvent,
56563 &_swigt__p_wxSizer,
56564 &_swigt__p_wxSizerItem,
56565 &_swigt__p_wxStaticBox,
56566 &_swigt__p_wxStaticBoxSizer,
56567 &_swigt__p_wxStdDialogButtonSizer,
56568 &_swigt__p_wxSysColourChangedEvent,
56569 &_swigt__p_wxTIFFHandler,
56570 &_swigt__p_wxToolTip,
56571 &_swigt__p_wxUpdateUIEvent,
56572 &_swigt__p_wxValidator,
56573 &_swigt__p_wxVisualAttributes,
56574 &_swigt__p_wxWindow,
56575 &_swigt__p_wxWindowCreateEvent,
56576 &_swigt__p_wxWindowDestroyEvent,
56577 &_swigt__p_wxXPMHandler,
56578 &_swigt__p_wxZipFSHandler,
56579 };
56580
56581 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56582 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56583 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56584 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56585 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56586 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56587 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56588 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56589 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56590 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56591 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56592 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56593 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56594 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56595 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}};
56596 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56597 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}};
56598 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56599 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}};
56600 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56601 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56602 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56603 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56604 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56605 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}};
56606 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56607 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}};
56608 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56609 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56610 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56611 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56612 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56613 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56614 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56615 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56616 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56617 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}};
56618 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56619 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56620 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}};
56621 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56622 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56623 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}};
56624 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}};
56625 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56626 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56627 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56628 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56629 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56630 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56631 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56632 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56633 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}};
56634 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56635 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}};
56636 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56637 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56638 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56639 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}};
56640 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56641 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56642 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56643 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56644 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56645 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56646 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56647 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}};
56648 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56649 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56650 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56651 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56652 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56653 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56654 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56655 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56656 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56657 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56658 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56659 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56660 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56661 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56662 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56663 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56665 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}};
56666 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56667 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56668 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56669 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56670 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56671 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56672 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56673 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56674 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56675 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56676 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56680 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56681 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56683 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56684 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56697 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}};
56698 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}};
56699 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56700 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56703 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56704 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56705 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56706 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}};
56707 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56708 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}};
56709 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56710 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56712 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56713
56714 static swig_cast_info *swig_cast_initial[] = {
56715 _swigc__p_buffer,
56716 _swigc__p_char,
56717 _swigc__p_form_ops_t,
56718 _swigc__p_int,
56719 _swigc__p_long,
56720 _swigc__p_unsigned_char,
56721 _swigc__p_unsigned_int,
56722 _swigc__p_unsigned_long,
56723 _swigc__p_wxANIHandler,
56724 _swigc__p_wxAcceleratorEntry,
56725 _swigc__p_wxAcceleratorTable,
56726 _swigc__p_wxActivateEvent,
56727 _swigc__p_wxAppTraits,
56728 _swigc__p_wxArrayString,
56729 _swigc__p_wxBMPHandler,
56730 _swigc__p_wxBitmap,
56731 _swigc__p_wxBoxSizer,
56732 _swigc__p_wxButton,
56733 _swigc__p_wxCURHandler,
56734 _swigc__p_wxCaret,
56735 _swigc__p_wxChildFocusEvent,
56736 _swigc__p_wxClipboardTextEvent,
56737 _swigc__p_wxCloseEvent,
56738 _swigc__p_wxColour,
56739 _swigc__p_wxCommandEvent,
56740 _swigc__p_wxContextMenuEvent,
56741 _swigc__p_wxControl,
56742 _swigc__p_wxControlWithItems,
56743 _swigc__p_wxCursor,
56744 _swigc__p_wxDC,
56745 _swigc__p_wxDateEvent,
56746 _swigc__p_wxDateTime,
56747 _swigc__p_wxDisplayChangedEvent,
56748 _swigc__p_wxDropFilesEvent,
56749 _swigc__p_wxDuplexMode,
56750 _swigc__p_wxEraseEvent,
56751 _swigc__p_wxEvent,
56752 _swigc__p_wxEventLoop,
56753 _swigc__p_wxEventLoopActivator,
56754 _swigc__p_wxEvtHandler,
56755 _swigc__p_wxFSFile,
56756 _swigc__p_wxFileSystem,
56757 _swigc__p_wxFileSystemHandler,
56758 _swigc__p_wxFlexGridSizer,
56759 _swigc__p_wxFocusEvent,
56760 _swigc__p_wxFont,
56761 _swigc__p_wxFrame,
56762 _swigc__p_wxGBPosition,
56763 _swigc__p_wxGBSizerItem,
56764 _swigc__p_wxGBSpan,
56765 _swigc__p_wxGIFHandler,
56766 _swigc__p_wxGridBagSizer,
56767 _swigc__p_wxGridSizer,
56768 _swigc__p_wxHelpEvent__Origin,
56769 _swigc__p_wxICOHandler,
56770 _swigc__p_wxIconizeEvent,
56771 _swigc__p_wxIdleEvent,
56772 _swigc__p_wxImage,
56773 _swigc__p_wxImageHandler,
56774 _swigc__p_wxImageHistogram,
56775 _swigc__p_wxImage_HSVValue,
56776 _swigc__p_wxImage_RGBValue,
56777 _swigc__p_wxIndividualLayoutConstraint,
56778 _swigc__p_wxInitDialogEvent,
56779 _swigc__p_wxInputStream,
56780 _swigc__p_wxInternetFSHandler,
56781 _swigc__p_wxItemContainer,
56782 _swigc__p_wxJPEGHandler,
56783 _swigc__p_wxKeyEvent,
56784 _swigc__p_wxLayoutConstraints,
56785 _swigc__p_wxMaximizeEvent,
56786 _swigc__p_wxMemoryFSHandler,
56787 _swigc__p_wxMenu,
56788 _swigc__p_wxMenuBar,
56789 _swigc__p_wxMenuBarBase,
56790 _swigc__p_wxMenuEvent,
56791 _swigc__p_wxMenuItem,
56792 _swigc__p_wxMouseCaptureChangedEvent,
56793 _swigc__p_wxMouseCaptureLostEvent,
56794 _swigc__p_wxMouseEvent,
56795 _swigc__p_wxMoveEvent,
56796 _swigc__p_wxNavigationKeyEvent,
56797 _swigc__p_wxNcPaintEvent,
56798 _swigc__p_wxNotifyEvent,
56799 _swigc__p_wxObject,
56800 _swigc__p_wxOutputStream,
56801 _swigc__p_wxPCXHandler,
56802 _swigc__p_wxPNGHandler,
56803 _swigc__p_wxPNMHandler,
56804 _swigc__p_wxPaintEvent,
56805 _swigc__p_wxPaletteChangedEvent,
56806 _swigc__p_wxPaperSize,
56807 _swigc__p_wxPoint,
56808 _swigc__p_wxPoint2D,
56809 _swigc__p_wxPropagateOnce,
56810 _swigc__p_wxPropagationDisabler,
56811 _swigc__p_wxPyApp,
56812 _swigc__p_wxPyCommandEvent,
56813 _swigc__p_wxPyDropTarget,
56814 _swigc__p_wxPyEvent,
56815 _swigc__p_wxPyFileSystemHandler,
56816 _swigc__p_wxPyImageHandler,
56817 _swigc__p_wxPyInputStream,
56818 _swigc__p_wxPySizer,
56819 _swigc__p_wxPyValidator,
56820 _swigc__p_wxQuantize,
56821 _swigc__p_wxQueryNewPaletteEvent,
56822 _swigc__p_wxRealPoint,
56823 _swigc__p_wxRect,
56824 _swigc__p_wxRegion,
56825 _swigc__p_wxScrollEvent,
56826 _swigc__p_wxScrollWinEvent,
56827 _swigc__p_wxSetCursorEvent,
56828 _swigc__p_wxShowEvent,
56829 _swigc__p_wxSize,
56830 _swigc__p_wxSizeEvent,
56831 _swigc__p_wxSizer,
56832 _swigc__p_wxSizerItem,
56833 _swigc__p_wxStaticBox,
56834 _swigc__p_wxStaticBoxSizer,
56835 _swigc__p_wxStdDialogButtonSizer,
56836 _swigc__p_wxSysColourChangedEvent,
56837 _swigc__p_wxTIFFHandler,
56838 _swigc__p_wxToolTip,
56839 _swigc__p_wxUpdateUIEvent,
56840 _swigc__p_wxValidator,
56841 _swigc__p_wxVisualAttributes,
56842 _swigc__p_wxWindow,
56843 _swigc__p_wxWindowCreateEvent,
56844 _swigc__p_wxWindowDestroyEvent,
56845 _swigc__p_wxXPMHandler,
56846 _swigc__p_wxZipFSHandler,
56847 };
56848
56849
56850 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56851
56852 static swig_const_info swig_const_table[] = {
56853 {0, 0, 0, 0.0, 0, 0}};
56854
56855 #ifdef __cplusplus
56856 }
56857 #endif
56858 /* -----------------------------------------------------------------------------
56859 * Type initialization:
56860 * This problem is tough by the requirement that no dynamic
56861 * memory is used. Also, since swig_type_info structures store pointers to
56862 * swig_cast_info structures and swig_cast_info structures store pointers back
56863 * to swig_type_info structures, we need some lookup code at initialization.
56864 * The idea is that swig generates all the structures that are needed.
56865 * The runtime then collects these partially filled structures.
56866 * The SWIG_InitializeModule function takes these initial arrays out of
56867 * swig_module, and does all the lookup, filling in the swig_module.types
56868 * array with the correct data and linking the correct swig_cast_info
56869 * structures together.
56870 *
56871 * The generated swig_type_info structures are assigned staticly to an initial
56872 * array. We just loop though that array, and handle each type individually.
56873 * First we lookup if this type has been already loaded, and if so, use the
56874 * loaded structure instead of the generated one. Then we have to fill in the
56875 * cast linked list. The cast data is initially stored in something like a
56876 * two-dimensional array. Each row corresponds to a type (there are the same
56877 * number of rows as there are in the swig_type_initial array). Each entry in
56878 * a column is one of the swig_cast_info structures for that type.
56879 * The cast_initial array is actually an array of arrays, because each row has
56880 * a variable number of columns. So to actually build the cast linked list,
56881 * we find the array of casts associated with the type, and loop through it
56882 * adding the casts to the list. The one last trick we need to do is making
56883 * sure the type pointer in the swig_cast_info struct is correct.
56884 *
56885 * First off, we lookup the cast->type name to see if it is already loaded.
56886 * There are three cases to handle:
56887 * 1) If the cast->type has already been loaded AND the type we are adding
56888 * casting info to has not been loaded (it is in this module), THEN we
56889 * replace the cast->type pointer with the type pointer that has already
56890 * been loaded.
56891 * 2) If BOTH types (the one we are adding casting info to, and the
56892 * cast->type) are loaded, THEN the cast info has already been loaded by
56893 * the previous module so we just ignore it.
56894 * 3) Finally, if cast->type has not already been loaded, then we add that
56895 * swig_cast_info to the linked list (because the cast->type) pointer will
56896 * be correct.
56897 * ----------------------------------------------------------------------------- */
56898
56899 #ifdef __cplusplus
56900 extern "C" {
56901 #if 0
56902 } /* c-mode */
56903 #endif
56904 #endif
56905
56906 #if 0
56907 #define SWIGRUNTIME_DEBUG
56908 #endif
56909
56910 SWIGRUNTIME void
56911 SWIG_InitializeModule(void *clientdata) {
56912 size_t i;
56913 swig_module_info *module_head;
56914 static int init_run = 0;
56915
56916 clientdata = clientdata;
56917
56918 if (init_run) return;
56919 init_run = 1;
56920
56921 /* Initialize the swig_module */
56922 swig_module.type_initial = swig_type_initial;
56923 swig_module.cast_initial = swig_cast_initial;
56924
56925 /* Try and load any already created modules */
56926 module_head = SWIG_GetModule(clientdata);
56927 if (module_head) {
56928 swig_module.next = module_head->next;
56929 module_head->next = &swig_module;
56930 } else {
56931 /* This is the first module loaded */
56932 swig_module.next = &swig_module;
56933 SWIG_SetModule(clientdata, &swig_module);
56934 }
56935
56936 /* Now work on filling in swig_module.types */
56937 #ifdef SWIGRUNTIME_DEBUG
56938 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56939 #endif
56940 for (i = 0; i < swig_module.size; ++i) {
56941 swig_type_info *type = 0;
56942 swig_type_info *ret;
56943 swig_cast_info *cast;
56944
56945 #ifdef SWIGRUNTIME_DEBUG
56946 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56947 #endif
56948
56949 /* if there is another module already loaded */
56950 if (swig_module.next != &swig_module) {
56951 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56952 }
56953 if (type) {
56954 /* Overwrite clientdata field */
56955 #ifdef SWIGRUNTIME_DEBUG
56956 printf("SWIG_InitializeModule: found type %s\n", type->name);
56957 #endif
56958 if (swig_module.type_initial[i]->clientdata) {
56959 type->clientdata = swig_module.type_initial[i]->clientdata;
56960 #ifdef SWIGRUNTIME_DEBUG
56961 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56962 #endif
56963 }
56964 } else {
56965 type = swig_module.type_initial[i];
56966 }
56967
56968 /* Insert casting types */
56969 cast = swig_module.cast_initial[i];
56970 while (cast->type) {
56971 /* Don't need to add information already in the list */
56972 ret = 0;
56973 #ifdef SWIGRUNTIME_DEBUG
56974 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56975 #endif
56976 if (swig_module.next != &swig_module) {
56977 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56978 #ifdef SWIGRUNTIME_DEBUG
56979 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56980 #endif
56981 }
56982 if (ret) {
56983 if (type == swig_module.type_initial[i]) {
56984 #ifdef SWIGRUNTIME_DEBUG
56985 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56986 #endif
56987 cast->type = ret;
56988 ret = 0;
56989 } else {
56990 /* Check for casting already in the list */
56991 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56992 #ifdef SWIGRUNTIME_DEBUG
56993 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56994 #endif
56995 if (!ocast) ret = 0;
56996 }
56997 }
56998
56999 if (!ret) {
57000 #ifdef SWIGRUNTIME_DEBUG
57001 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57002 #endif
57003 if (type->cast) {
57004 type->cast->prev = cast;
57005 cast->next = type->cast;
57006 }
57007 type->cast = cast;
57008 }
57009 cast++;
57010 }
57011 /* Set entry in modules->types array equal to the type */
57012 swig_module.types[i] = type;
57013 }
57014 swig_module.types[i] = 0;
57015
57016 #ifdef SWIGRUNTIME_DEBUG
57017 printf("**** SWIG_InitializeModule: Cast List ******\n");
57018 for (i = 0; i < swig_module.size; ++i) {
57019 int j = 0;
57020 swig_cast_info *cast = swig_module.cast_initial[i];
57021 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57022 while (cast->type) {
57023 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57024 cast++;
57025 ++j;
57026 }
57027 printf("---- Total casts: %d\n",j);
57028 }
57029 printf("**** SWIG_InitializeModule: Cast List ******\n");
57030 #endif
57031 }
57032
57033 /* This function will propagate the clientdata field of type to
57034 * any new swig_type_info structures that have been added into the list
57035 * of equivalent types. It is like calling
57036 * SWIG_TypeClientData(type, clientdata) a second time.
57037 */
57038 SWIGRUNTIME void
57039 SWIG_PropagateClientData(void) {
57040 size_t i;
57041 swig_cast_info *equiv;
57042 static int init_run = 0;
57043
57044 if (init_run) return;
57045 init_run = 1;
57046
57047 for (i = 0; i < swig_module.size; i++) {
57048 if (swig_module.types[i]->clientdata) {
57049 equiv = swig_module.types[i]->cast;
57050 while (equiv) {
57051 if (!equiv->converter) {
57052 if (equiv->type && !equiv->type->clientdata)
57053 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57054 }
57055 equiv = equiv->next;
57056 }
57057 }
57058 }
57059 }
57060
57061 #ifdef __cplusplus
57062 #if 0
57063 {
57064 /* c-mode */
57065 #endif
57066 }
57067 #endif
57068
57069
57070
57071 #ifdef __cplusplus
57072 extern "C" {
57073 #endif
57074
57075 /* Python-specific SWIG API */
57076 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57077 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57078 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57079
57080 /* -----------------------------------------------------------------------------
57081 * global variable support code.
57082 * ----------------------------------------------------------------------------- */
57083
57084 typedef struct swig_globalvar {
57085 char *name; /* Name of global variable */
57086 PyObject *(*get_attr)(void); /* Return the current value */
57087 int (*set_attr)(PyObject *); /* Set the value */
57088 struct swig_globalvar *next;
57089 } swig_globalvar;
57090
57091 typedef struct swig_varlinkobject {
57092 PyObject_HEAD
57093 swig_globalvar *vars;
57094 } swig_varlinkobject;
57095
57096 SWIGINTERN PyObject *
57097 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57098 return PyString_FromString("<Swig global variables>");
57099 }
57100
57101 SWIGINTERN PyObject *
57102 swig_varlink_str(swig_varlinkobject *v) {
57103 PyObject *str = PyString_FromString("(");
57104 swig_globalvar *var;
57105 for (var = v->vars; var; var=var->next) {
57106 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57107 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57108 }
57109 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57110 return str;
57111 }
57112
57113 SWIGINTERN int
57114 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57115 PyObject *str = swig_varlink_str(v);
57116 fprintf(fp,"Swig global variables ");
57117 fprintf(fp,"%s\n", PyString_AsString(str));
57118 Py_DECREF(str);
57119 return 0;
57120 }
57121
57122 SWIGINTERN void
57123 swig_varlink_dealloc(swig_varlinkobject *v) {
57124 swig_globalvar *var = v->vars;
57125 while (var) {
57126 swig_globalvar *n = var->next;
57127 free(var->name);
57128 free(var);
57129 var = n;
57130 }
57131 }
57132
57133 SWIGINTERN PyObject *
57134 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57135 PyObject *res = NULL;
57136 swig_globalvar *var = v->vars;
57137 while (var) {
57138 if (strcmp(var->name,n) == 0) {
57139 res = (*var->get_attr)();
57140 break;
57141 }
57142 var = var->next;
57143 }
57144 if (res == NULL && !PyErr_Occurred()) {
57145 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57146 }
57147 return res;
57148 }
57149
57150 SWIGINTERN int
57151 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57152 int res = 1;
57153 swig_globalvar *var = v->vars;
57154 while (var) {
57155 if (strcmp(var->name,n) == 0) {
57156 res = (*var->set_attr)(p);
57157 break;
57158 }
57159 var = var->next;
57160 }
57161 if (res == 1 && !PyErr_Occurred()) {
57162 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57163 }
57164 return res;
57165 }
57166
57167 SWIGINTERN PyTypeObject*
57168 swig_varlink_type(void) {
57169 static char varlink__doc__[] = "Swig var link object";
57170 static PyTypeObject varlink_type;
57171 static int type_init = 0;
57172 if (!type_init) {
57173 const PyTypeObject tmp
57174 = {
57175 PyObject_HEAD_INIT(NULL)
57176 0, /* Number of items in variable part (ob_size) */
57177 (char *)"swigvarlink", /* Type name (tp_name) */
57178 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57179 0, /* Itemsize (tp_itemsize) */
57180 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57181 (printfunc) swig_varlink_print, /* Print (tp_print) */
57182 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57183 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57184 0, /* tp_compare */
57185 (reprfunc) swig_varlink_repr, /* tp_repr */
57186 0, /* tp_as_number */
57187 0, /* tp_as_sequence */
57188 0, /* tp_as_mapping */
57189 0, /* tp_hash */
57190 0, /* tp_call */
57191 (reprfunc)swig_varlink_str, /* tp_str */
57192 0, /* tp_getattro */
57193 0, /* tp_setattro */
57194 0, /* tp_as_buffer */
57195 0, /* tp_flags */
57196 varlink__doc__, /* tp_doc */
57197 0, /* tp_traverse */
57198 0, /* tp_clear */
57199 0, /* tp_richcompare */
57200 0, /* tp_weaklistoffset */
57201 #if PY_VERSION_HEX >= 0x02020000
57202 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57203 #endif
57204 #if PY_VERSION_HEX >= 0x02030000
57205 0, /* tp_del */
57206 #endif
57207 #ifdef COUNT_ALLOCS
57208 0,0,0,0 /* tp_alloc -> tp_next */
57209 #endif
57210 };
57211 varlink_type = tmp;
57212 varlink_type.ob_type = &PyType_Type;
57213 type_init = 1;
57214 }
57215 return &varlink_type;
57216 }
57217
57218 /* Create a variable linking object for use later */
57219 SWIGINTERN PyObject *
57220 SWIG_Python_newvarlink(void) {
57221 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57222 if (result) {
57223 result->vars = 0;
57224 }
57225 return ((PyObject*) result);
57226 }
57227
57228 SWIGINTERN void
57229 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57230 swig_varlinkobject *v = (swig_varlinkobject *) p;
57231 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57232 if (gv) {
57233 size_t size = strlen(name)+1;
57234 gv->name = (char *)malloc(size);
57235 if (gv->name) {
57236 strncpy(gv->name,name,size);
57237 gv->get_attr = get_attr;
57238 gv->set_attr = set_attr;
57239 gv->next = v->vars;
57240 }
57241 }
57242 v->vars = gv;
57243 }
57244
57245 SWIGINTERN PyObject *
57246 SWIG_globals() {
57247 static PyObject *_SWIG_globals = 0;
57248 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57249 return _SWIG_globals;
57250 }
57251
57252 /* -----------------------------------------------------------------------------
57253 * constants/methods manipulation
57254 * ----------------------------------------------------------------------------- */
57255
57256 /* Install Constants */
57257 SWIGINTERN void
57258 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57259 PyObject *obj = 0;
57260 size_t i;
57261 for (i = 0; constants[i].type; ++i) {
57262 switch(constants[i].type) {
57263 case SWIG_PY_POINTER:
57264 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57265 break;
57266 case SWIG_PY_BINARY:
57267 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57268 break;
57269 default:
57270 obj = 0;
57271 break;
57272 }
57273 if (obj) {
57274 PyDict_SetItemString(d, constants[i].name, obj);
57275 Py_DECREF(obj);
57276 }
57277 }
57278 }
57279
57280 /* -----------------------------------------------------------------------------*/
57281 /* Fix SwigMethods to carry the callback ptrs when needed */
57282 /* -----------------------------------------------------------------------------*/
57283
57284 SWIGINTERN void
57285 SWIG_Python_FixMethods(PyMethodDef *methods,
57286 swig_const_info *const_table,
57287 swig_type_info **types,
57288 swig_type_info **types_initial) {
57289 size_t i;
57290 for (i = 0; methods[i].ml_name; ++i) {
57291 const char *c = methods[i].ml_doc;
57292 if (c && (c = strstr(c, "swig_ptr: "))) {
57293 int j;
57294 swig_const_info *ci = 0;
57295 const char *name = c + 10;
57296 for (j = 0; const_table[j].type; ++j) {
57297 if (strncmp(const_table[j].name, name,
57298 strlen(const_table[j].name)) == 0) {
57299 ci = &(const_table[j]);
57300 break;
57301 }
57302 }
57303 if (ci) {
57304 size_t shift = (ci->ptype) - types;
57305 swig_type_info *ty = types_initial[shift];
57306 size_t ldoc = (c - methods[i].ml_doc);
57307 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57308 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57309 if (ndoc) {
57310 char *buff = ndoc;
57311 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57312 if (ptr) {
57313 strncpy(buff, methods[i].ml_doc, ldoc);
57314 buff += ldoc;
57315 strncpy(buff, "swig_ptr: ", 10);
57316 buff += 10;
57317 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57318 methods[i].ml_doc = ndoc;
57319 }
57320 }
57321 }
57322 }
57323 }
57324 }
57325
57326 #ifdef __cplusplus
57327 }
57328 #endif
57329
57330 /* -----------------------------------------------------------------------------*
57331 * Partial Init method
57332 * -----------------------------------------------------------------------------*/
57333
57334 #ifdef __cplusplus
57335 extern "C"
57336 #endif
57337 SWIGEXPORT void SWIG_init(void) {
57338 PyObject *m, *d;
57339
57340 /* Fix SwigMethods to carry the callback ptrs when needed */
57341 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57342
57343 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57344 d = PyModule_GetDict(m);
57345
57346 SWIG_InitializeModule(0);
57347 SWIG_InstallConstants(d,swig_const_table);
57348
57349
57350
57351 #ifndef wxPyUSE_EXPORT
57352 // Make our API structure a CObject so other modules can import it
57353 // from this module.
57354 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57355 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57356 Py_XDECREF(cobj);
57357 #endif
57358
57359 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57360 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57361 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57362 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57363 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57364 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57365 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57366 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57367 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57368 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57369 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57370 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57371 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57372 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57373 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57374 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57375 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57376 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57377 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57378 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57379 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57380 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57381 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57382 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57383 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57384 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57385 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57386 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57387 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57388 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57389 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57390 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57391 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57392 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57393 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57394 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57395 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57396 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57397 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57398 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57399 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57400 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57401 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57402 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57403 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57404 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57405 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57406 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57407 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57408 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57409 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57410 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57411 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57412 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57413 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57414 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57415 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57416 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57417 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57418 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57419 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57420 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57421 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57422 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57423 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57424 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57425 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57426 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57427 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57428 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57429 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57430 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57431 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57432 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57433 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57434 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57435 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57436 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57437 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57438 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57439 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57440 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57441 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57442 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57443 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57444 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57445 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57446 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57447 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57448 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57449 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57450 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57451 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57452 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57453 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57454 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57455 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57456 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57457 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57458 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57459 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57460 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57461 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57462 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57463 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57464 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57465 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57466 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57467 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57468 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57469 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57470 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57471 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57472 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57473 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57474 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57475 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57476 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57477 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57478 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57479 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57480 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57481 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57482 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57483 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57484 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57485 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57486 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57487 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57488 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57489 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57490 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57491 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57492 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57493 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57494 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57495 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57496 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57497 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57498 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57499 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57500 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57501 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57502 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57503 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57504 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57505 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57506 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57507 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57508 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57509 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57510 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57511 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57512 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57513 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57514 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57515 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57516 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57517 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57518 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57519 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57520 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57521 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57522 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57523 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57524 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57525 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57526 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57527 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57528 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57529 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57530 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57531 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57532 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57533 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57534 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57535 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57536 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57537 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57538 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57539 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57540 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57541 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57542 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57543 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57544 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57545 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57546 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57547 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57548 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57549 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57550 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57551 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57552 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57553 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57554 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57555 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57556 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57557 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57558 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57559 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57560 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57561 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57562 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57563 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57564 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57565 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57566 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57567 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57568 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57569 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57570 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57571 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57572 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57573 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57574 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57575 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57576 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57577 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57578 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57579 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57580 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57581 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57582 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57583 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57584 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57585 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57586 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57587 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57588 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57589 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57590 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57591 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57592 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57593 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57594 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57595 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57596 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57597 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57598 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57599 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57600 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57601 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57602 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57603 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57604 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57605 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57606 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57607 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57608 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57609 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57610 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57611 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57612 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57613 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57614 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57615 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57616 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57617 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57618 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57619 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57620 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57621 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57622 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57623 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57624 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57625 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57626 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57627 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57628 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57629 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57630 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57631 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57632 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57633 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57634 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57635 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57636 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57637 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57638 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57639 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57640 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57641 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57642 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57643 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57644 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57645 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57646 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57647 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57648 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57649 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57650 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57651 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57652 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57653 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57654 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57655 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57656 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57657 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57658 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57659 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57660 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57661 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57662 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57663 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57664 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57665 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57666 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57667 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57668 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57669 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57670 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57671 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57672 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57673 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57674 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57675 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57676 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57677 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57678 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57679 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57680 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57681 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57682 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57683 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57684 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57685 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57686 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57687 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57688 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57689 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57690 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57691 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57692 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57693 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57694 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57695 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57696 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57697 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57698 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57699 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57700 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57701 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57702 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57703 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57704 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57705 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57706 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57707 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57708 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57709 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57710 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57711 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57712 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57713 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57714 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57715 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57716 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57717 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57718 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57719 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57720 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57721 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57722 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57723 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57724 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57725 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57726 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57727 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57728 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57729 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57730 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57731 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57732 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57733 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57734 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57735 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57736 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57737 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57738 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57739 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57740 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57741 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57742 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57743 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57744 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57745 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57746 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57747 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57748 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57749 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57750 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57751 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57752 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57753 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57754 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57755 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57756 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57757 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57758 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57759 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57760 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57761 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57762 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57780 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57781 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57782 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57783 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57784 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57785 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57786 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57787 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57788 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57789 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57790 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57791 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57792 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57793 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57794 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57795 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57796 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57797 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57798 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57799 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57800 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57801 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57802 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57803 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57804 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57805 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57806 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57807 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57808 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57809 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57810 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57811 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57812 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57813 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57814 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57815 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57816 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57817 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57818 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57819 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57820 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57821 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57822 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57823 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57824 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57825 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57826 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57827 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57828 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57829 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57830 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57831 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57832 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57833 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57834 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57835 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57836 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57837 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57838 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57839 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57840 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57841 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57842 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57843 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57844 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57845 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57846 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57847 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57848 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57849 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57850 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57851 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57852 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57853 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57854 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57855 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57856 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57857 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57858 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57859 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57860 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57861 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57862 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57863 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57864 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57865 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57866 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57867 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57868 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57869 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57870 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57871 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57872 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57873 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57874 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57875 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57876 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57877 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57878 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57879 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57880 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57881 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57882 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57883 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57884 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57885 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57886 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57887 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57888 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57889 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57890 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57891 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57892 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57893 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57894 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57895 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57896 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57897 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57898 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57899 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57900 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57901 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57902 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57903 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57904 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57905 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57906 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57907 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57908 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57909 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57910 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57911 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57912 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57913 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57914 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57915 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57916 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57917 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57918 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57920 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57921 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57922 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57923 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57924 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57925 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57926 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57927 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57928 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57929 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57930 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57931 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57932 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57933 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57934 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57935 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57936 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57937 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57938 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57939 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57940 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57941 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57942 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57943 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57944 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57945 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57946 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57947 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57948 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57949 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57950 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57951 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57952 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57953 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57954 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57955 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57956 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57957 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57958 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57959 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57960 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57961 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57962 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57963 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57964 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57965 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57966 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57967 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57968 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57969 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57970 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57971 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57982 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57983 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57984 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57985 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57986 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57987 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57988 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57989 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57990 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57991 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57992 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57993 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57994 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57995 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57996 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57997 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57998 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57999 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58000 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58001 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58002 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58003 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58004 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58005 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58006 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58007 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58008 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58009 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58010 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58011 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58012 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58013 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58014 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58015 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58016 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58017 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58018
58019 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58020
58021
58022 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58023
58024 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58025 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58026 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58027 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58028 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58029 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58030 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58031 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58032 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58033 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58034 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58035 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58036 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58037 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58038 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58039 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58040 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58041 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58045 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58046 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58047 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58048 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58049 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58050 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58051 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58052 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58053 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58054 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58055 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58056 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58057 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58058 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58059 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58060 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58061 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58062 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58063 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58064 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58065 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58066 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58067 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58068 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58069 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58070 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58071 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58072 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58073 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58074 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58075 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58076 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58077 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58078 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58079 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58080 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58081 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58082 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58083 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58084 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58085 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58086 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58087 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58088 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58089 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58090 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58091 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58092 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58093 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58094 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58095 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58096 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58097 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58098 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58099 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58100 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58101 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58102 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58103 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58104 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58105 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58106 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58107 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58108 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58109 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58110 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58111 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58112 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58113 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58114 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58115 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58116 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58117 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58118 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58119 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58120 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58121 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58122 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58123 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58124 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58125 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58126 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58127 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58128 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58129 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58130 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58131 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58132 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58133 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58134 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58135 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58136 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58137 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58138 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58139 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58140 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58141 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58142 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58143 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58144 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58145 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58146 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58147 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58148 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58149 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58150 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58151 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58152 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58153 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58154 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58155 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58156 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58157 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58158 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58159 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58160 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58161 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58162 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58163 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58164 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58165 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58166 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58167 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58168 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58169 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58170 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58171 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58172 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58173 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58174 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58175 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58176 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58177 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58178 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58179 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58180 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58181 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58182 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58183 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58184 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58185 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58186 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58187 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58188 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58189 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58190 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58191 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58192 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58193 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58194 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58195 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58196 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58197 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58198 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58199 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58200 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58201 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58202 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58203 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58204 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58205 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58206 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58207 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58208 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58209 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58210 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58211 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58212 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58213 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58214 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58215 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58216 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58217 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58218 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58219 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58220 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58221 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58222 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58223 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58224 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58225 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58226 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58227 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58228 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58229 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58230 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58231 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58232 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58233 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58234 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58235 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58236 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58237 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58238
58239 // Initialize threading, some globals and such
58240 __wxPyPreStart(d);
58241
58242
58243 // Although these are defined in __version__ they need to be here too so
58244 // that an assert can be done to ensure that the wxPython and the wxWindows
58245 // versions match.
58246 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58247 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58248 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58249
58250 }
58251
wxWidgets (Impactor)