]> 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
Elippsis and markup support for wxStaticText
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPropagateOnce swig_types[96]
2563 #define SWIGTYPE_p_wxPropagationDisabler swig_types[97]
2564 #define SWIGTYPE_p_wxPyApp swig_types[98]
2565 #define SWIGTYPE_p_wxPyCommandEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyDropTarget swig_types[100]
2567 #define SWIGTYPE_p_wxPyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyImageHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyInputStream swig_types[104]
2571 #define SWIGTYPE_p_wxPySizer swig_types[105]
2572 #define SWIGTYPE_p_wxPyValidator swig_types[106]
2573 #define SWIGTYPE_p_wxQuantize swig_types[107]
2574 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[108]
2575 #define SWIGTYPE_p_wxRealPoint swig_types[109]
2576 #define SWIGTYPE_p_wxRect swig_types[110]
2577 #define SWIGTYPE_p_wxRect2D swig_types[111]
2578 #define SWIGTYPE_p_wxRegion swig_types[112]
2579 #define SWIGTYPE_p_wxScrollEvent swig_types[113]
2580 #define SWIGTYPE_p_wxScrollWinEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSetCursorEvent swig_types[115]
2582 #define SWIGTYPE_p_wxShowEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSize swig_types[117]
2584 #define SWIGTYPE_p_wxSizeEvent swig_types[118]
2585 #define SWIGTYPE_p_wxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSizerFlags swig_types[120]
2587 #define SWIGTYPE_p_wxSizerItem swig_types[121]
2588 #define SWIGTYPE_p_wxStaticBox swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[123]
2590 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[124]
2591 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[125]
2592 #define SWIGTYPE_p_wxTGAHandler swig_types[126]
2593 #define SWIGTYPE_p_wxTIFFHandler swig_types[127]
2594 #define SWIGTYPE_p_wxToolTip swig_types[128]
2595 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[129]
2596 #define SWIGTYPE_p_wxValidator swig_types[130]
2597 #define SWIGTYPE_p_wxVisualAttributes swig_types[131]
2598 #define SWIGTYPE_p_wxWindow swig_types[132]
2599 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[133]
2600 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxXPMHandler swig_types[135]
2602 #define SWIGTYPE_p_wxZipFSHandler swig_types[136]
2603 static swig_type_info *swig_types[138];
2604 static swig_module_info swig_module = {swig_types, 137, 0, 0, 0, 0};
2605 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2606 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2607
2608 /* -------- TYPES TABLE (END) -------- */
2609
2610 #if (PY_VERSION_HEX <= 0x02000000)
2611 # if !defined(SWIG_PYTHON_CLASSIC)
2612 # error "This python version requires to use swig with the '-classic' option"
2613 # endif
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodern' option"
2617 #endif
2618 #if (PY_VERSION_HEX <= 0x02020000)
2619 # error "This python version requires to use swig with the '-nomodernargs' option"
2620 #endif
2621 #ifndef METH_O
2622 # error "This python version requires to use swig with the '-nofastunpack' option"
2623 #endif
2624
2625 /*-----------------------------------------------
2626 @(target):= _core_.so
2627 ------------------------------------------------*/
2628 #define SWIG_init init_core_
2629
2630 #define SWIG_name "_core_"
2631
2632 #define SWIGVERSION 0x010329
2633
2634
2635 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2636 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2637
2638
2639 #include <stdexcept>
2640
2641
2642 namespace swig {
2643 class PyObject_ptr {
2644 protected:
2645 PyObject *_obj;
2646
2647 public:
2648 PyObject_ptr() :_obj(0)
2649 {
2650 }
2651
2652 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2653 {
2654 Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2658 {
2659 if (initial_ref) Py_XINCREF(_obj);
2660 }
2661
2662 PyObject_ptr & operator=(const PyObject_ptr& item)
2663 {
2664 Py_XINCREF(item._obj);
2665 Py_XDECREF(_obj);
2666 _obj = item._obj;
2667 return *this;
2668 }
2669
2670 ~PyObject_ptr()
2671 {
2672 Py_XDECREF(_obj);
2673 }
2674
2675 operator PyObject *() const
2676 {
2677 return _obj;
2678 }
2679
2680 PyObject *operator->() const
2681 {
2682 return _obj;
2683 }
2684 };
2685 }
2686
2687
2688 namespace swig {
2689 struct PyObject_var : PyObject_ptr {
2690 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2691
2692 PyObject_var & operator = (PyObject* obj)
2693 {
2694 Py_XDECREF(_obj);
2695 _obj = obj;
2696 return *this;
2697 }
2698 };
2699 }
2700
2701
2702 #include "wx/wxPython/wxPython_int.h"
2703 #include "wx/wxPython/pyclasses.h"
2704 #include "wx/wxPython/twoitem.h"
2705
2706
2707 #ifndef wxPyUSE_EXPORT
2708 // Helper functions for dealing with SWIG objects and such. These are
2709 // located here so they know about the SWIG types and functions declared
2710 // in the wrapper code.
2711
2712 #include <wx/hashmap.h>
2713 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2714
2715
2716 // Maintains a hashmap of className to swig_type_info pointers. Given the
2717 // name of a class either looks up the type info in the cache, or scans the
2718 // SWIG tables for it.
2719 extern PyObject* wxPyPtrTypeMap;
2720 static
2721 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2722
2723 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2724
2725 if (typeInfoCache == NULL)
2726 typeInfoCache = new wxPyTypeInfoHashMap;
2727
2728 wxString name(className);
2729 swig_type_info* swigType = (*typeInfoCache)[name];
2730
2731 if (! swigType) {
2732 // it wasn't in the cache, so look it up from SWIG
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735
2736 // if it still wasn't found, try looking for a mapped name
2737 if (!swigType) {
2738 PyObject* item;
2739 name = className;
2740
2741 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2742 (char*)(const char*)name.mbc_str())) != NULL) {
2743 name = wxString(PyString_AsString(item), *wxConvCurrent);
2744 name.Append(wxT(" *"));
2745 swigType = SWIG_TypeQuery(name.mb_str());
2746 }
2747 }
2748 if (swigType) {
2749 // and add it to the map if found
2750 (*typeInfoCache)[className] = swigType;
2751 }
2752 }
2753 return swigType;
2754 }
2755
2756
2757 // Check if a class name is a type known to SWIG
2758 bool wxPyCheckSwigType(const wxChar* className) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 return swigType != NULL;
2762 }
2763
2764
2765 // Given a pointer to a C++ object and a class name, construct a Python proxy
2766 // object for it.
2767 PyObject* wxPyConstructObject(void* ptr,
2768 const wxChar* className,
2769 int setThisOwn) {
2770
2771 swig_type_info* swigType = wxPyFindSwigType(className);
2772 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2773
2774 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2775 }
2776
2777
2778 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2779 // Ensures that the proxy object is of the specified (or derived) type. If
2780 // not able to perform the conversion then a Python exception is set and the
2781 // error should be handled properly in the caller. Returns True on success.
2782 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2783 const wxChar* className) {
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2787
2788 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2789 }
2790
2791
2792
2793 // Make a SWIGified pointer object suitable for a .this attribute
2794 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2795
2796 PyObject* robj = NULL;
2797
2798 swig_type_info* swigType = wxPyFindSwigType(className);
2799 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2800
2801 robj = PySwigObject_New(ptr, swigType, 0);
2802 return robj;
2803 }
2804
2805
2806 // Python's PyInstance_Check does not return True for instances of new-style
2807 // classes. This should get close enough for both new and old classes but I
2808 // should re-evaluate the need for doing instance checks...
2809 bool wxPyInstance_Check(PyObject* obj) {
2810 return PyObject_HasAttrString(obj, "__class__") != 0;
2811 }
2812
2813
2814 // This one checks if the object is an instance of a SWIG proxy class (it has
2815 // a .this attribute, and the .this attribute is a PySwigObject.)
2816 bool wxPySwigInstance_Check(PyObject* obj) {
2817 static PyObject* this_str = NULL;
2818 if (this_str == NULL)
2819 this_str = PyString_FromString("this");
2820
2821 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2822 if (this_attr) {
2823 bool retval = (PySwigObject_Check(this_attr) != 0);
2824 Py_DECREF(this_attr);
2825 return retval;
2826 }
2827
2828 PyErr_Clear();
2829 return false;
2830 }
2831
2832
2833 // Export a C API in a struct. Other modules will be able to load this from
2834 // the wx._core_ module and will then have safe access to these functions,
2835 // even if they are located in another shared library.
2836 static wxPyCoreAPI API = {
2837
2838 wxPyCheckSwigType,
2839 wxPyConstructObject,
2840 wxPyConvertSwigPtr,
2841 wxPyMakeSwigPtr,
2842
2843 wxPyBeginAllowThreads,
2844 wxPyEndAllowThreads,
2845 wxPyBeginBlockThreads,
2846 wxPyEndBlockThreads,
2847
2848 wxPy_ConvertList,
2849
2850 wxString_in_helper,
2851 Py2wxString,
2852 wx2PyString,
2853
2854 byte_LIST_helper,
2855 int_LIST_helper,
2856 long_LIST_helper,
2857 string_LIST_helper,
2858 wxPoint_LIST_helper,
2859 wxBitmap_LIST_helper,
2860 wxString_LIST_helper,
2861 wxAcceleratorEntry_LIST_helper,
2862
2863 wxSize_helper,
2864 wxPoint_helper,
2865 wxRealPoint_helper,
2866 wxRect_helper,
2867 wxColour_helper,
2868 wxPoint2D_helper,
2869
2870 wxPySimple_typecheck,
2871 wxColour_typecheck,
2872
2873 wxPyCBH_setCallbackInfo,
2874 wxPyCBH_findCallback,
2875 wxPyCBH_callCallback,
2876 wxPyCBH_callCallbackObj,
2877 wxPyCBH_delete,
2878
2879 wxPyMake_wxObject,
2880 wxPyMake_wxSizer,
2881 wxPyPtrTypeMap_Add,
2882 wxPy2int_seq_helper,
2883 wxPy4int_seq_helper,
2884 wxArrayString2PyList_helper,
2885 wxArrayInt2PyList_helper,
2886
2887 wxPyClientData_dtor,
2888 wxPyUserData_dtor,
2889 wxPyOORClientData_dtor,
2890
2891 wxPyCBInputStream_create,
2892 wxPyCBInputStream_copy,
2893
2894 wxPyInstance_Check,
2895 wxPySwigInstance_Check,
2896
2897 wxPyCheckForApp,
2898
2899 wxArrayDouble2PyList_helper,
2900 wxPoint2D_LIST_helper,
2901 wxRect2D_helper,
2902
2903 };
2904
2905 #endif
2906
2907
2908 #if !WXWIN_COMPATIBILITY_2_4
2909 #define wxHIDE_READONLY 0
2910 #endif
2911
2912
2913 #define SWIG_From_long PyInt_FromLong
2914
2915
2916 SWIGINTERNINLINE PyObject *
2917 SWIG_From_int (int value)
2918 {
2919 return SWIG_From_long (value);
2920 }
2921
2922 static const wxString wxPyEmptyString(wxEmptyString);
2923 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2924 return self->GetClassInfo()->GetClassName();
2925 }
2926 SWIGINTERN void wxObject_Destroy(wxObject *self){
2927 delete self;
2928 }
2929
2930 #ifndef __WXMAC__
2931 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2932 #endif
2933
2934
2935 #include <limits.h>
2936 #ifndef LLONG_MIN
2937 # define LLONG_MIN LONG_LONG_MIN
2938 #endif
2939 #ifndef LLONG_MAX
2940 # define LLONG_MAX LONG_LONG_MAX
2941 #endif
2942 #ifndef ULLONG_MAX
2943 # define ULLONG_MAX ULONG_LONG_MAX
2944 #endif
2945
2946
2947 SWIGINTERN int
2948 SWIG_AsVal_long (PyObject* obj, long* val)
2949 {
2950 if (PyNumber_Check(obj)) {
2951 if (val) *val = PyInt_AsLong(obj);
2952 return SWIG_OK;
2953 }
2954 return SWIG_TypeError;
2955 }
2956
2957
2958 SWIGINTERN int
2959 SWIG_AsVal_int (PyObject * obj, int *val)
2960 {
2961 long v;
2962 int res = SWIG_AsVal_long (obj, &v);
2963 if (SWIG_IsOK(res)) {
2964 if ((v < INT_MIN || v > INT_MAX)) {
2965 return SWIG_OverflowError;
2966 } else {
2967 if (val) *val = static_cast< int >(v);
2968 }
2969 }
2970 return res;
2971 }
2972
2973 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return false;
2976 if ( ! wxSize_helper(other, &obj) ) {
2977 PyErr_Clear();
2978 return false;
2979 }
2980 return self->operator==(*obj);
2981 }
2982 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2983 wxSize temp, *obj = &temp;
2984 if ( other == Py_None ) return true;
2985 if ( ! wxSize_helper(other, &obj)) {
2986 PyErr_Clear();
2987 return true;
2988 }
2989 return self->operator!=(*obj);
2990 }
2991
2992 #include <float.h>
2993
2994
2995 SWIGINTERN int
2996 SWIG_AsVal_double (PyObject *obj, double* val)
2997 {
2998 if (PyNumber_Check(obj)) {
2999 if (val) *val = PyFloat_AsDouble(obj);
3000 return SWIG_OK;
3001 }
3002 return SWIG_TypeError;
3003 }
3004
3005
3006 SWIGINTERN int
3007 SWIG_AsVal_float (PyObject * obj, float *val)
3008 {
3009 double v;
3010 int res = SWIG_AsVal_double (obj, &v);
3011 if (SWIG_IsOK(res)) {
3012 if ((v < -FLT_MAX || v > FLT_MAX)) {
3013 return SWIG_OverflowError;
3014 } else {
3015 if (val) *val = static_cast< float >(v);
3016 }
3017 }
3018 return res;
3019 }
3020
3021 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3022 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3026 //wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029
3030 #define SWIG_From_double PyFloat_FromDouble
3031
3032 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return false;
3035 if ( ! wxRealPoint_helper(other, &obj) ) {
3036 PyErr_Clear();
3037 return false;
3038 }
3039 return self->operator==(*obj);
3040 }
3041 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3042 wxRealPoint temp, *obj = &temp;
3043 if ( other == Py_None ) return true;
3044 if ( ! wxRealPoint_helper(other, &obj)) {
3045 PyErr_Clear();
3046 return true;
3047 }
3048 return self->operator!=(*obj);
3049 }
3050 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3051 self->x = x;
3052 self->y = y;
3053 }
3054 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3055 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3056 PyObject* tup = PyTuple_New(2);
3057 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3058 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3059 //PyEndBlockThreads(blocked);
3060 return tup;
3061 }
3062 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return false;
3065 if ( ! wxPoint_helper(other, &obj) ) {
3066 PyErr_Clear();
3067 return false;
3068 }
3069 return self->operator==(*obj);
3070 }
3071 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3072 wxPoint temp, *obj = &temp;
3073 if ( other == Py_None ) return true;
3074 if ( ! wxPoint_helper(other, &obj)) {
3075 PyErr_Clear();
3076 return true;
3077 }
3078 return self->operator!=(*obj);
3079 }
3080 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3081 self->x = x;
3082 self->y = y;
3083 }
3084 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3085 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3086 PyObject* tup = PyTuple_New(2);
3087 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3088 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3089 //wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return false;
3095 if ( ! wxRect_helper(other, &obj) ) {
3096 PyErr_Clear();
3097 return false;
3098 }
3099 return self->operator==(*obj);
3100 }
3101 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3102 wxRect temp, *obj = &temp;
3103 if ( other == Py_None ) return true;
3104 if ( ! wxRect_helper(other, &obj)) {
3105 PyErr_Clear();
3106 return true;
3107 }
3108 return self->operator!=(*obj);
3109 }
3110 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3111 self->x = x;
3112 self->y = y;
3113 self->width = width;
3114 self->height = height;
3115 }
3116 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3117 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3118 PyObject* tup = PyTuple_New(4);
3119 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3120 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3121 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3122 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3123 //wxPyEndBlockThreads(blocked);
3124 return tup;
3125 }
3126
3127 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3128 wxRegion reg1(*r1);
3129 wxRegion reg2(*r2);
3130 wxRect dest(0,0,0,0);
3131 PyObject* obj;
3132
3133 reg1.Intersect(reg2);
3134 dest = reg1.GetBox();
3135
3136 if (dest != wxRect(0,0,0,0)) {
3137 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxRect* newRect = new wxRect(dest);
3139 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3140 //wxPyEndBlockThreads(blocked);
3141 return obj;
3142 }
3143 Py_INCREF(Py_None);
3144 return Py_None;
3145 }
3146
3147 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return false;
3150 if ( ! wxPoint2D_helper(other, &obj) ) {
3151 PyErr_Clear();
3152 return false;
3153 }
3154 return self->operator==(*obj);
3155 }
3156 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3157 wxPoint2D temp, *obj = &temp;
3158 if ( other == Py_None ) return true;
3159 if ( ! wxPoint2D_helper(other, &obj)) {
3160 PyErr_Clear();
3161 return true;
3162 }
3163 return self->operator!=(*obj);
3164 }
3165 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3166 self->m_x = x;
3167 self->m_y = y;
3168 }
3169 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3170 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 PyObject* tup = PyTuple_New(2);
3172 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3173 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3174 //wxPyEndBlockThreads(blocked);
3175 return tup;
3176 }
3177 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3178 wxRect2D temp, *obj = &temp;
3179 if ( other == Py_None ) return false;
3180 if ( ! wxRect2D_helper(other, &obj) ) {
3181 PyErr_Clear();
3182 return false;
3183 }
3184 return self->operator==(*obj);
3185 }
3186 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3187 wxRect2D temp, *obj = &temp;
3188 if ( other == Py_None ) return true;
3189 if ( ! wxRect2D_helper(other, &obj)) {
3190 PyErr_Clear();
3191 return true;
3192 }
3193 return self->operator!=(*obj);
3194 }
3195 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3196 self->m_x = x;
3197 self->m_y = y;
3198 self->m_width = width;
3199 self->m_height = height;
3200 }
3201 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3202 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3203 PyObject* tup = PyTuple_New(4);
3204 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3205 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3206 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3207 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3208 //wxPyEndBlockThreads(blocked);
3209 return tup;
3210 }
3211
3212 #include "wx/wxPython/pyistream.h"
3213
3214 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3215 wxInputStream* wxis = wxPyCBInputStream::create(p);
3216 if (wxis)
3217 return new wxPyInputStream(wxis);
3218 else
3219 return NULL;
3220 }
3221
3222 SWIGINTERN swig_type_info*
3223 SWIG_pchar_descriptor()
3224 {
3225 static int init = 0;
3226 static swig_type_info* info = 0;
3227 if (!init) {
3228 info = SWIG_TypeQuery("_p_char");
3229 init = 1;
3230 }
3231 return info;
3232 }
3233
3234
3235 SWIGINTERNINLINE PyObject *
3236 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3237 {
3238 if (carray) {
3239 if (size > INT_MAX) {
3240 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3241 return pchar_descriptor ?
3242 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3243 } else {
3244 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3245 }
3246 } else {
3247 return SWIG_Py_Void();
3248 }
3249 }
3250
3251
3252 SWIGINTERNINLINE PyObject *
3253 SWIG_From_char (char c)
3254 {
3255 return SWIG_FromCharPtrAndSize(&c,1);
3256 }
3257
3258
3259 SWIGINTERNINLINE PyObject*
3260 SWIG_From_unsigned_SS_long (unsigned long value)
3261 {
3262 return (value > LONG_MAX) ?
3263 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3264 }
3265
3266
3267 SWIGINTERNINLINE PyObject *
3268 SWIG_From_size_t (size_t value)
3269 {
3270 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3271 }
3272
3273
3274 SWIGINTERN int
3275 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3276 {
3277 if (PyString_Check(obj)) {
3278 char *cstr; Py_ssize_t len;
3279 PyString_AsStringAndSize(obj, &cstr, &len);
3280 if (cptr) {
3281 if (alloc) {
3282 /*
3283 In python the user should not be able to modify the inner
3284 string representation. To warranty that, if you define
3285 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3286 buffer is always returned.
3287
3288 The default behavior is just to return the pointer value,
3289 so, be careful.
3290 */
3291 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3292 if (*alloc != SWIG_OLDOBJ)
3293 #else
3294 if (*alloc == SWIG_NEWOBJ)
3295 #endif
3296 {
3297 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3298 *alloc = SWIG_NEWOBJ;
3299 }
3300 else {
3301 *cptr = cstr;
3302 *alloc = SWIG_OLDOBJ;
3303 }
3304 } else {
3305 *cptr = PyString_AsString(obj);
3306 }
3307 }
3308 if (psize) *psize = len + 1;
3309 return SWIG_OK;
3310 } else {
3311 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3312 if (pchar_descriptor) {
3313 void* vptr = 0;
3314 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3315 if (cptr) *cptr = (char *) vptr;
3316 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3317 if (alloc) *alloc = SWIG_OLDOBJ;
3318 return SWIG_OK;
3319 }
3320 }
3321 }
3322 return SWIG_TypeError;
3323 }
3324
3325
3326 SWIGINTERN int
3327 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3328 {
3329 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3330 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3331 if (SWIG_IsOK(res)) {
3332 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3333 if (csize <= size) {
3334 if (val) {
3335 if (csize) memcpy(val, cptr, csize*sizeof(char));
3336 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3337 }
3338 if (alloc == SWIG_NEWOBJ) {
3339 delete[] cptr;
3340 res = SWIG_DelNewMask(res);
3341 }
3342 return res;
3343 }
3344 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3345 }
3346 return SWIG_TypeError;
3347 }
3348
3349
3350 SWIGINTERN int
3351 SWIG_AsVal_char (PyObject * obj, char *val)
3352 {
3353 int res = SWIG_AsCharArray(obj, val, 1);
3354 if (!SWIG_IsOK(res)) {
3355 long v;
3356 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3357 if (SWIG_IsOK(res)) {
3358 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3359 if (val) *val = static_cast< char >(v);
3360 } else {
3361 res = SWIG_OverflowError;
3362 }
3363 }
3364 }
3365 return res;
3366 }
3367
3368 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3369 // We use only strings for the streams, not unicode
3370 PyObject* str = PyObject_Str(obj);
3371 if (! str) {
3372 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3373 return;
3374 }
3375 self->Write(PyString_AS_STRING(str),
3376 PyString_GET_SIZE(str));
3377 Py_DECREF(str);
3378 }
3379
3380 #include "wx/wxPython/pyistream.h"
3381
3382
3383 class wxPyFileSystemHandler : public wxFileSystemHandler
3384 {
3385 public:
3386 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3387
3388 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3389 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3390 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3391 DEC_PYCALLBACK_STRING__pure(FindNext);
3392
3393 wxString GetProtocol(const wxString& location) {
3394 return wxFileSystemHandler::GetProtocol(location);
3395 }
3396
3397 wxString GetLeftLocation(const wxString& location) {
3398 return wxFileSystemHandler::GetLeftLocation(location);
3399 }
3400
3401 wxString GetAnchor(const wxString& location) {
3402 return wxFileSystemHandler::GetAnchor(location);
3403 }
3404
3405 wxString GetRightLocation(const wxString& location) {
3406 return wxFileSystemHandler::GetRightLocation(location);
3407 }
3408
3409 wxString GetMimeTypeFromExt(const wxString& location) {
3410 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3411 }
3412
3413 PYPRIVATE;
3414 };
3415
3416
3417 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3418 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3419 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3420 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_bool (PyObject *obj, bool *val)
3425 {
3426 if (obj == Py_True) {
3427 if (val) *val = true;
3428 return SWIG_OK;
3429 } else if (obj == Py_False) {
3430 if (val) *val = false;
3431 return SWIG_OK;
3432 } else {
3433 long v = 0;
3434 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3435 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3436 return res;
3437 }
3438 }
3439
3440 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3441 wxFileName fname = wxFileSystem::URLToFileName(url);
3442 return fname.GetFullPath();
3443 }
3444
3445 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3446 wxImage& image,
3447 long type) {
3448 wxMemoryFSHandler::AddFile(filename, image, type);
3449 }
3450
3451 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3452 const wxBitmap& bitmap,
3453 long type) {
3454 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3455 }
3456
3457 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3458 PyObject* data) {
3459 if (! PyString_Check(data)) {
3460 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3461 "Expected string object"));
3462 return;
3463 }
3464
3465 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3466 void* ptr = (void*)PyString_AsString(data);
3467 size_t size = PyString_Size(data);
3468 wxPyEndBlockThreads(blocked);
3469
3470 wxMemoryFSHandler::AddFile(filename, ptr, size);
3471 }
3472
3473
3474 #include "wx/wxPython/pyistream.h"
3475
3476
3477 SWIGINTERN int
3478 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3479 {
3480 long v = 0;
3481 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3482 return SWIG_TypeError;
3483 }
3484 else if (val)
3485 *val = (unsigned long)v;
3486 return SWIG_OK;
3487 }
3488
3489
3490 SWIGINTERN int
3491 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3492 {
3493 unsigned long v;
3494 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3495 if (SWIG_IsOK(res)) {
3496 if ((v > UCHAR_MAX)) {
3497 return SWIG_OverflowError;
3498 } else {
3499 if (val) *val = static_cast< unsigned char >(v);
3500 }
3501 }
3502 return res;
3503 }
3504
3505
3506 SWIGINTERNINLINE PyObject *
3507 SWIG_From_unsigned_SS_char (unsigned char value)
3508 {
3509 return SWIG_From_unsigned_SS_long (value);
3510 }
3511
3512 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3513 wxImageHistogramEntry e = (*self)[key];
3514 return e.value;
3515 }
3516 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3517 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3518 wxImageHistogramEntry e = (*self)[key];
3519 return e.value;
3520 }
3521 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3522 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3523 colour.Green(),
3524 colour.Blue());
3525 wxImageHistogramEntry e = (*self)[key];
3526 return e.value;
3527 }
3528
3529 // Pull the nested class out to the top level for SWIG's sake
3530 #define wxImage_RGBValue wxImage::RGBValue
3531 #define wxImage_HSVValue wxImage::HSVValue
3532
3533 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3534 if (width > 0 && height > 0)
3535 return new wxImage(width, height, clear);
3536 else
3537 return new wxImage;
3538 }
3539 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3540 return new wxImage(bitmap.ConvertToImage());
3541 }
3542 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3543 if (DATASIZE != width*height*3) {
3544 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3545 return NULL;
3546 }
3547
3548 // Copy the source data so the wxImage can clean it up later
3549 buffer copy = (buffer)malloc(DATASIZE);
3550 if (copy == NULL) {
3551 wxPyBLOCK_THREADS(PyErr_NoMemory());
3552 return NULL;
3553 }
3554 memcpy(copy, data, DATASIZE);
3555 return new wxImage(width, height, copy, false);
3556 }
3557 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3558 if (DATASIZE != width*height*3) {
3559 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3560 return NULL;
3561 }
3562 if (ALPHASIZE != width*height) {
3563 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3564 return NULL;
3565 }
3566
3567 // Copy the source data so the wxImage can clean it up later
3568 buffer dcopy = (buffer)malloc(DATASIZE);
3569 if (dcopy == NULL) {
3570 wxPyBLOCK_THREADS(PyErr_NoMemory());
3571 return NULL;
3572 }
3573 memcpy(dcopy, data, DATASIZE);
3574
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return NULL;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581
3582 return new wxImage(width, height, dcopy, acopy, false);
3583 }
3584 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3585 wxSize size(self->GetWidth(), self->GetHeight());
3586 return size;
3587 }
3588 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3589 buffer data = self->GetData();
3590 int len = self->GetWidth() * self->GetHeight() * 3;
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3596 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3598 return;
3599 }
3600 buffer copy = (buffer)malloc(DATASIZE);
3601 if (copy == NULL) {
3602 wxPyBLOCK_THREADS(PyErr_NoMemory());
3603 return;
3604 }
3605 memcpy(copy, data, DATASIZE);
3606 self->SetData(copy, false);
3607 // wxImage takes ownership of copy...
3608 }
3609 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3610 buffer data = self->GetData();
3611 int len = self->GetWidth() * self->GetHeight() * 3;
3612 PyObject* rv;
3613 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3614 return rv;
3615 }
3616 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3617 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3618 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3619 return;
3620 }
3621 self->SetData(data, true);
3622 }
3623 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3624 buffer data = self->GetAlpha();
3625 if (! data) {
3626 RETURN_NONE();
3627 } else {
3628 int len = self->GetWidth() * self->GetHeight();
3629 PyObject* rv;
3630 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3631 return rv;
3632 }
3633 }
3634 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3635 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3636 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3637 return;
3638 }
3639 buffer acopy = (buffer)malloc(ALPHASIZE);
3640 if (acopy == NULL) {
3641 wxPyBLOCK_THREADS(PyErr_NoMemory());
3642 return;
3643 }
3644 memcpy(acopy, alpha, ALPHASIZE);
3645 self->SetAlpha(acopy, false);
3646 // wxImage takes ownership of acopy...
3647 }
3648 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3649 buffer data = self->GetAlpha();
3650 int len = self->GetWidth() * self->GetHeight();
3651 PyObject* rv;
3652 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3653 return rv;
3654 }
3655 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3656 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3657 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3658 return;
3659 }
3660 self->SetAlpha(alpha, true);
3661 }
3662 SWIGINTERN PyObject *wxImage_GetHandlers(){
3663 wxList& list = wxImage::GetHandlers();
3664 return wxPy_ConvertList(&list);
3665 }
3666 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3667 wxBitmap bitmap(*self, depth);
3668 return bitmap;
3669 }
3670 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3671 wxImage mono = self->ConvertToMono( red, green, blue );
3672 wxBitmap bitmap( mono, 1 );
3673 return bitmap;
3674 }
3675
3676 wxImage* _ImageFromBuffer(int width, int height,
3677 buffer data, int DATASIZE,
3678 buffer alpha=NULL, int ALPHASIZE=0)
3679 {
3680 if (DATASIZE != width*height*3) {
3681 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3682 return NULL;
3683 }
3684 if (alpha != NULL) {
3685 if (ALPHASIZE != width*height) {
3686 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3687 return NULL;
3688 }
3689 return new wxImage(width, height, data, alpha, true);
3690 }
3691 return new wxImage(width, height, data, true);
3692 }
3693
3694 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3695 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3696 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3697 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3700 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3701 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3702 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3703 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3704 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3705 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3706 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3707 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3708 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3709
3710 #include <wx/imagtga.h>
3711
3712
3713 #include <wx/quantize.h>
3714
3715 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3716 return wxQuantize::Quantize(src, dest,
3717 //NULL, // palette
3718 desiredNoColours,
3719 NULL, // eightBitData
3720 flags);
3721 }
3722 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3723 if (PyCallable_Check(func)) {
3724 self->Connect(id, lastId, eventType,
3725 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3726 new wxPyCallback(func));
3727 }
3728 else if (func == Py_None) {
3729 self->Disconnect(id, lastId, eventType,
3730 (wxObjectEventFunction)
3731 &wxPyCallback::EventThunker);
3732 }
3733 else {
3734 wxPyBLOCK_THREADS(
3735 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3736 }
3737 }
3738 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3739 return self->Disconnect(id, lastId, eventType,
3740 (wxObjectEventFunction)
3741 &wxPyCallback::EventThunker);
3742 }
3743 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3744 if (_self && _self != Py_None) {
3745 self->SetClientObject(new wxPyOORClientData(_self, incref));
3746 }
3747 else {
3748 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3749 if (data) {
3750 self->SetClientObject(NULL); // This will delete it too
3751 }
3752 }
3753 }
3754
3755 #if ! wxUSE_HOTKEY
3756 #define wxEVT_HOTKEY -9999
3757 #endif
3758
3759 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3760 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3761 if (data) {
3762 Py_INCREF(data->m_obj);
3763 return data->m_obj;
3764 } else {
3765 Py_INCREF(Py_None);
3766 return Py_None;
3767 }
3768 }
3769 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3770 wxPyClientData* data = new wxPyClientData(clientData);
3771 self->SetClientObject(data);
3772 }
3773 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3774 #if wxUSE_UNICODE
3775 return self->GetUnicodeKey();
3776 #else
3777 return 0;
3778 #endif
3779 }
3780 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3781 #if wxUSE_UNICODE
3782 self->m_uniChar = uniChar;
3783 #endif
3784 }
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_From_unsigned_SS_int (unsigned int value)
3788 {
3789 return SWIG_From_unsigned_SS_long (value);
3790 }
3791
3792
3793 SWIGINTERN int
3794 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3795 {
3796 unsigned long v;
3797 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3798 if (SWIG_IsOK(res)) {
3799 if ((v > UINT_MAX)) {
3800 return SWIG_OverflowError;
3801 } else {
3802 if (val) *val = static_cast< unsigned int >(v);
3803 }
3804 }
3805 return res;
3806 }
3807
3808 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3809 self->m_size = size;
3810 }
3811 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3812 int count = self->GetNumberOfFiles();
3813 wxString* files = self->GetFiles();
3814 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3815 PyObject* list = PyList_New(count);
3816
3817 if (!list) {
3818 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3819 wxPyEndBlockThreads(blocked);
3820 return NULL;
3821 }
3822
3823 for (int i=0; i<count; i++) {
3824 PyList_SetItem(list, i, wx2PyString(files[i]));
3825 }
3826 wxPyEndBlockThreads(blocked);
3827 return list;
3828 }
3829
3830
3831 SWIGINTERN wxPyApp *new_wxPyApp(){
3832 wxPythonApp = new wxPyApp();
3833 return wxPythonApp;
3834 }
3835 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3836 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3837 return wxPyTestDisplayAvailable();
3838 }
3839
3840 void wxApp_CleanUp() {
3841 __wxPyCleanup();
3842 }
3843
3844
3845 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3846
3847
3848
3849
3850
3851 SWIGINTERNINLINE PyObject *
3852 SWIG_FromCharPtr(const char *cptr)
3853 {
3854 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3855 }
3856
3857
3858 #if 0 // #ifdef __WXMAC__
3859
3860 // A dummy class that raises an exception if used...
3861 class wxEventLoop
3862 {
3863 public:
3864 wxEventLoop() { wxPyRaiseNotImplemented(); }
3865 int Run() { return 0; }
3866 void Exit(int rc = 0) {}
3867 bool Pending() const { return false; }
3868 bool Dispatch() { return false; }
3869 bool IsRunning() const { return false; }
3870 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3871 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3872 };
3873
3874 #else
3875
3876 #include <wx/evtloop.h>
3877
3878 #endif
3879
3880
3881
3882 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3883 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3884 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3885 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3886 wxWindowList& list = self->GetChildren();
3887 return wxPy_ConvertList(&list);
3888 }
3889 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3890 return wxGetTopLevelParent(self);
3891 }
3892 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3893 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3894 #if wxUSE_HOTKEY
3895 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3896 #else
3897 return false;
3898 #endif
3899 }
3900 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3901
3902
3903
3904 return false;
3905
3906 }
3907 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3908 return wxPyGetWinHandle(self);
3909 }
3910 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3911 self->AssociateHandle((WXWidget)handle);
3912 }
3913 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3914
3915 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowById(id, parent);
3917 }
3918
3919 wxWindow* wxFindWindowByName( const wxString& name,
3920 const wxWindow *parent = NULL ) {
3921 return wxWindow::FindWindowByName(name, parent);
3922 }
3923
3924 wxWindow* wxFindWindowByLabel( const wxString& label,
3925 const wxWindow *parent = NULL ) {
3926 return wxWindow::FindWindowByLabel(label, parent);
3927 }
3928
3929
3930 #ifdef __WXMSW__
3931 #include <wx/msw/private.h> // to get wxGetWindowId
3932 #endif
3933
3934
3935 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3936 #ifdef __WXMSW__
3937 WXHWND hWnd = (WXHWND)_hWnd;
3938 long id = wxGetWindowId(hWnd);
3939 wxWindow* win = new wxWindow;
3940 if (parent)
3941 parent->AddChild(win);
3942 win->SetEventHandler(win);
3943 win->SetHWND(hWnd);
3944 win->SetId(id);
3945 win->SubclassWin(hWnd);
3946 win->AdoptAttributesFromHWND();
3947 win->SetupColours();
3948 return win;
3949 #else
3950 wxPyRaiseNotImplemented();
3951 return NULL;
3952 #endif
3953 }
3954
3955
3956 PyObject* GetTopLevelWindows() {
3957 return wxPy_ConvertList(&wxTopLevelWindows);
3958 }
3959
3960
3961 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3962 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3963 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3964
3965 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3966
3967
3968 SWIGINTERNINLINE int
3969 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3970 {
3971 unsigned long v;
3972 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3973 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3974 return res;
3975 }
3976
3977 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3978 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3979 wxMenuItemList& list = self->GetMenuItems();
3980 return wxPy_ConvertList(&list);
3981 }
3982 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3983 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3984 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3985 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3986 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3987 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3988 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3989 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3990 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3991 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3992 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3993 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3994 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3995 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3996 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3997 static const wxString wxPyControlNameStr(wxControlNameStr);
3998 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3999 if (clientData) {
4000 wxPyClientData* data = new wxPyClientData(clientData);
4001 return self->Append(item, data);
4002 } else
4003 return self->Append(item);
4004 }
4005 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4006 if (clientData) {
4007 wxPyClientData* data = new wxPyClientData(clientData);
4008 return self->Insert(item, pos, data);
4009 } else
4010 return self->Insert(item, pos);
4011 }
4012 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4013 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4014 if (data) {
4015 Py_INCREF(data->m_obj);
4016 return data->m_obj;
4017 } else {
4018 Py_INCREF(Py_None);
4019 return Py_None;
4020 }
4021 }
4022 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4023 wxPyClientData* data = new wxPyClientData(clientData);
4024 self->SetClientObject(n, data);
4025 }
4026
4027
4028 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4029 if (borderInPixels == -1)
4030 return self->Border(direction);
4031 else
4032 return self->Border(direction, borderInPixels);
4033 }
4034 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4035 wxPyUserData* data = NULL;
4036 if ( userData ) {
4037 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4038 data = new wxPyUserData(userData);
4039 wxPyEndBlockThreads(blocked);
4040 }
4041 return new wxSizerItem(window, proportion, flag, border, data);
4042 }
4043 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4044 wxPyUserData* data = NULL;
4045 if ( userData ) {
4046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4047 data = new wxPyUserData(userData);
4048 wxPyEndBlockThreads(blocked);
4049 }
4050 return new wxSizerItem(width, height, proportion, flag, border, data);
4051 }
4052 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4053 wxPyUserData* data = NULL;
4054 if ( userData ) {
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 data = new wxPyUserData(userData);
4057 wxPyEndBlockThreads(blocked);
4058 }
4059 return new wxSizerItem(sizer, proportion, flag, border, data);
4060 }
4061
4062 SWIGINTERNINLINE PyObject *
4063 SWIG_From_float (float value)
4064 {
4065 return SWIG_From_double (value);
4066 }
4067
4068 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4069 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4070 if (data) {
4071 Py_INCREF(data->m_obj);
4072 return data->m_obj;
4073 } else {
4074 Py_INCREF(Py_None);
4075 return Py_None;
4076 }
4077 }
4078 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4079 wxPyUserData* data = NULL;
4080 if ( userData ) {
4081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4082 data = new wxPyUserData(userData);
4083 wxPyEndBlockThreads(blocked);
4084 }
4085 self->SetUserData(data);
4086 }
4087
4088 // Figure out the type of the sizer item
4089
4090 struct wxPySizerItemInfo {
4091 wxPySizerItemInfo()
4092 : window(NULL), sizer(NULL), gotSize(false),
4093 size(wxDefaultSize), gotPos(false), pos(-1)
4094 {}
4095
4096 wxWindow* window;
4097 wxSizer* sizer;
4098 bool gotSize;
4099 wxSize size;
4100 bool gotPos;
4101 int pos;
4102 };
4103
4104 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4105
4106 wxPySizerItemInfo info;
4107 wxSize size;
4108 wxSize* sizePtr = &size;
4109
4110 // Find out what the type of the item is
4111 // try wxWindow
4112 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4113 PyErr_Clear();
4114 info.window = NULL;
4115
4116 // try wxSizer
4117 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4118 PyErr_Clear();
4119 info.sizer = NULL;
4120
4121 // try wxSize or (w,h)
4122 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4123 info.size = *sizePtr;
4124 info.gotSize = true;
4125 }
4126
4127 // or a single int
4128 if (checkIdx && PyInt_Check(item)) {
4129 info.pos = PyInt_AsLong(item);
4130 info.gotPos = true;
4131 }
4132 }
4133 }
4134
4135 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4136 // no expected type, figure out what kind of error message to generate
4137 if ( !checkSize && !checkIdx )
4138 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4139 else if ( checkSize && !checkIdx )
4140 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4141 else if ( !checkSize && checkIdx)
4142 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4143 else
4144 // can this one happen?
4145 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4146 }
4147
4148 return info;
4149 }
4150
4151 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4152 if (!self->GetClientObject())
4153 self->SetClientObject(new wxPyOORClientData(_self));
4154 }
4155 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4156
4157 wxPyUserData* data = NULL;
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4160 if ( userData && (info.window || info.sizer || info.gotSize) )
4161 data = new wxPyUserData(userData);
4162 if ( info.sizer )
4163 PyObject_SetAttrString(item,"thisown",Py_False);
4164 wxPyEndBlockThreads(blocked);
4165
4166 // Now call the real Add method if a valid item type was found
4167 if ( info.window )
4168 return self->Add(info.window, proportion, flag, border, data);
4169 else if ( info.sizer )
4170 return self->Add(info.sizer, proportion, flag, border, data);
4171 else if (info.gotSize)
4172 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4173 proportion, flag, border, data);
4174 else
4175 return NULL;
4176 }
4177 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4178
4179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4180 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4181 if ( info.sizer )
4182 PyObject_SetAttrString(item,"thisown",Py_False);
4183 wxPyEndBlockThreads(blocked);
4184
4185 // Now call the real Add method if a valid item type was found
4186 if ( info.window )
4187 return self->Add(info.window, flags);
4188 else if ( info.sizer )
4189 return self->Add(info.sizer, flags);
4190 else if (info.gotSize)
4191 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4192 flags.GetProportion(),
4193 flags.GetFlags(),
4194 flags.GetBorderInPixels());
4195 else
4196 return NULL;
4197 }
4198 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4199
4200 wxPyUserData* data = NULL;
4201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4203 if ( userData && (info.window || info.sizer || info.gotSize) )
4204 data = new wxPyUserData(userData);
4205 if ( info.sizer )
4206 PyObject_SetAttrString(item,"thisown",Py_False);
4207 wxPyEndBlockThreads(blocked);
4208
4209 // Now call the real Insert method if a valid item type was found
4210 if ( info.window )
4211 return self->Insert(before, info.window, proportion, flag, border, data);
4212 else if ( info.sizer )
4213 return self->Insert(before, info.sizer, proportion, flag, border, data);
4214 else if (info.gotSize)
4215 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4216 proportion, flag, border, data);
4217 else
4218 return NULL;
4219 }
4220 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4221
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4224 if ( info.sizer )
4225 PyObject_SetAttrString(item,"thisown",Py_False);
4226 wxPyEndBlockThreads(blocked);
4227
4228 // Now call the real Insert method if a valid item type was found
4229 if ( info.window )
4230 return self->Insert(before, info.window, flags);
4231 else if ( info.sizer )
4232 return self->Insert(before, info.sizer, flags);
4233 else if (info.gotSize)
4234 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4235 flags.GetProportion(),
4236 flags.GetFlags(),
4237 flags.GetBorderInPixels());
4238 else
4239 return NULL;
4240 }
4241 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4242
4243 wxPyUserData* data = NULL;
4244 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4245 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4246 if ( userData && (info.window || info.sizer || info.gotSize) )
4247 data = new wxPyUserData(userData);
4248 if ( info.sizer )
4249 PyObject_SetAttrString(item,"thisown",Py_False);
4250 wxPyEndBlockThreads(blocked);
4251
4252 // Now call the real Prepend method if a valid item type was found
4253 if ( info.window )
4254 return self->Prepend(info.window, proportion, flag, border, data);
4255 else if ( info.sizer )
4256 return self->Prepend(info.sizer, proportion, flag, border, data);
4257 else if (info.gotSize)
4258 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4259 proportion, flag, border, data);
4260 else
4261 return NULL;
4262 }
4263 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4264
4265 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4266 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4267 if ( info.sizer )
4268 PyObject_SetAttrString(item,"thisown",Py_False);
4269 wxPyEndBlockThreads(blocked);
4270
4271 // Now call the real Add method if a valid item type was found
4272 if ( info.window )
4273 return self->Prepend(info.window, flags);
4274 else if ( info.sizer )
4275 return self->Prepend(info.sizer, flags);
4276 else if (info.gotSize)
4277 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4278 flags.GetProportion(),
4279 flags.GetFlags(),
4280 flags.GetBorderInPixels());
4281 else
4282 return NULL;
4283 }
4284 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4286 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4287 wxPyEndBlockThreads(blocked);
4288 if ( info.window )
4289 return false; //self->Remove(info.window);
4290 else if ( info.sizer )
4291 return self->Remove(info.sizer);
4292 else if ( info.gotPos )
4293 return self->Remove(info.pos);
4294 else
4295 return false;
4296 }
4297 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4300 wxPyEndBlockThreads(blocked);
4301 if ( info.window )
4302 return self->Detach(info.window);
4303 else if ( info.sizer )
4304 return self->Detach(info.sizer);
4305 else if ( info.gotPos )
4306 return self->Detach(info.pos);
4307 else
4308 return false;
4309 }
4310 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4312 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4313 wxPyEndBlockThreads(blocked);
4314 if ( info.window )
4315 return self->GetItem(info.window, recursive);
4316 else if ( info.sizer )
4317 return self->GetItem(info.sizer, recursive);
4318 else if ( info.gotPos )
4319 return self->GetItem(info.pos);
4320 else
4321 return NULL;
4322 }
4323 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4326 wxPyEndBlockThreads(blocked);
4327 if ( info.window )
4328 self->SetItemMinSize(info.window, size);
4329 else if ( info.sizer )
4330 self->SetItemMinSize(info.sizer, size);
4331 else if ( info.gotPos )
4332 self->SetItemMinSize(info.pos, size);
4333 }
4334 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4335 wxSizerItemList& list = self->GetChildren();
4336 return wxPy_ConvertList(&list);
4337 }
4338 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4340 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4341 wxPyEndBlockThreads(blocked);
4342 if ( info.window )
4343 return self->Show(info.window, show, recursive);
4344 else if ( info.sizer )
4345 return self->Show(info.sizer, show, recursive);
4346 else if ( info.gotPos )
4347 return self->Show(info.pos, show);
4348 else
4349 return false;
4350 }
4351 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4352 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4353 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4354 wxPyEndBlockThreads(blocked);
4355 if ( info.window )
4356 return self->IsShown(info.window);
4357 else if ( info.sizer )
4358 return self->IsShown(info.sizer);
4359 else if ( info.gotPos )
4360 return self->IsShown(info.pos);
4361 else
4362 return false;
4363 }
4364
4365 // See pyclasses.h
4366 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4367 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4368 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4369
4370
4371
4372
4373 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4374 {
4375 if (source == Py_None) {
4376 **obj = wxGBPosition(-1,-1);
4377 return true;
4378 }
4379 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4380 }
4381
4382 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4383 {
4384 if (source == Py_None) {
4385 **obj = wxGBSpan(-1,-1);
4386 return true;
4387 }
4388 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4389 }
4390
4391
4392 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4393 wxGBPosition temp, *obj = &temp;
4394 if ( other == Py_None ) return false;
4395 if ( ! wxGBPosition_helper(other, &obj) ) {
4396 PyErr_Clear();
4397 return false;
4398 }
4399 return self->operator==(*obj);
4400 }
4401 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4402 wxGBPosition temp, *obj = &temp;
4403 if ( other == Py_None ) return true;
4404 if ( ! wxGBPosition_helper(other, &obj)) {
4405 PyErr_Clear();
4406 return true;
4407 }
4408 return self->operator!=(*obj);
4409 }
4410 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4411 self->SetRow(row);
4412 self->SetCol(col);
4413 }
4414 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4415 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4416 PyObject* tup = PyTuple_New(2);
4417 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4418 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4419 wxPyEndBlockThreads(blocked);
4420 return tup;
4421 }
4422 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4423 wxGBSpan temp, *obj = &temp;
4424 if ( other == Py_None ) return false;
4425 if ( ! wxGBSpan_helper(other, &obj) ) {
4426 PyErr_Clear();
4427 return false;
4428 }
4429 return self->operator==(*obj);
4430 }
4431 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4432 wxGBSpan temp, *obj = &temp;
4433 if ( other == Py_None ) return true;
4434 if ( ! wxGBSpan_helper(other, &obj)) {
4435 PyErr_Clear();
4436 return true;
4437 }
4438 return self->operator!=(*obj);
4439 }
4440 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4441 self->SetRowspan(rowspan);
4442 self->SetColspan(colspan);
4443 }
4444 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4445 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4446 PyObject* tup = PyTuple_New(2);
4447 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4448 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4449 wxPyEndBlockThreads(blocked);
4450 return tup;
4451 }
4452 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4453 wxPyUserData* data = NULL;
4454 if ( userData ) {
4455 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4456 data = new wxPyUserData(userData);
4457 wxPyEndBlockThreads(blocked);
4458 }
4459 return new wxGBSizerItem(window, pos, span, flag, border, data);
4460 }
4461 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4462 wxPyUserData* data = NULL;
4463 if ( userData ) {
4464 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4465 data = new wxPyUserData(userData);
4466 wxPyEndBlockThreads(blocked);
4467 }
4468 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4469 }
4470 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4471 wxPyUserData* data = NULL;
4472 if ( userData ) {
4473 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4474 data = new wxPyUserData(userData);
4475 wxPyEndBlockThreads(blocked);
4476 }
4477 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4478 }
4479 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4480 int row, col;
4481 self->GetEndPos(row, col);
4482 return wxGBPosition(row, col);
4483 }
4484 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4485
4486 wxPyUserData* data = NULL;
4487 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4488 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4489 if ( userData && (info.window || info.sizer || info.gotSize) )
4490 data = new wxPyUserData(userData);
4491 if ( info.sizer )
4492 PyObject_SetAttrString(item,"thisown",Py_False);
4493 wxPyEndBlockThreads(blocked);
4494
4495 // Now call the real Add method if a valid item type was found
4496 if ( info.window )
4497 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4498 else if ( info.sizer )
4499 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4500 else if (info.gotSize)
4501 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4502 pos, span, flag, border, data);
4503 return NULL;
4504 }
4505
4506
4507 #ifdef __cplusplus
4508 extern "C" {
4509 #endif
4510 SWIGINTERN int EmptyString_set(PyObject *) {
4511 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4512 return 1;
4513 }
4514
4515
4516 SWIGINTERN PyObject *EmptyString_get(void) {
4517 PyObject *pyobj = 0;
4518
4519 {
4520 #if wxUSE_UNICODE
4521 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4522 #else
4523 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4524 #endif
4525 }
4526 return pyobj;
4527 }
4528
4529
4530 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4531 PyObject *resultobj = 0;
4532 wxObject *arg1 = (wxObject *) 0 ;
4533 wxString result;
4534 void *argp1 = 0 ;
4535 int res1 = 0 ;
4536 PyObject *swig_obj[1] ;
4537
4538 if (!args) SWIG_fail;
4539 swig_obj[0] = args;
4540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4541 if (!SWIG_IsOK(res1)) {
4542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4543 }
4544 arg1 = reinterpret_cast< wxObject * >(argp1);
4545 {
4546 PyThreadState* __tstate = wxPyBeginAllowThreads();
4547 result = wxObject_GetClassName(arg1);
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 {
4552 #if wxUSE_UNICODE
4553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4554 #else
4555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4556 #endif
4557 }
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxObject *arg1 = (wxObject *) 0 ;
4567 void *argp1 = 0 ;
4568 int res1 = 0 ;
4569 PyObject *swig_obj[1] ;
4570
4571 if (!args) SWIG_fail;
4572 swig_obj[0] = args;
4573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4576 }
4577 arg1 = reinterpret_cast< wxObject * >(argp1);
4578 {
4579 PyThreadState* __tstate = wxPyBeginAllowThreads();
4580 wxObject_Destroy(arg1);
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 resultobj = SWIG_Py_Void();
4585 return resultobj;
4586 fail:
4587 return NULL;
4588 }
4589
4590
4591 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4592 PyObject *resultobj = 0;
4593 wxObject *arg1 = (wxObject *) 0 ;
4594 wxObject *arg2 = 0 ;
4595 bool result;
4596 void *argp1 = 0 ;
4597 int res1 = 0 ;
4598 void *argp2 = 0 ;
4599 int res2 = 0 ;
4600 PyObject * obj0 = 0 ;
4601 PyObject * obj1 = 0 ;
4602 char * kwnames[] = {
4603 (char *) "self",(char *) "p", NULL
4604 };
4605
4606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4608 if (!SWIG_IsOK(res1)) {
4609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4610 }
4611 arg1 = reinterpret_cast< wxObject * >(argp1);
4612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4613 if (!SWIG_IsOK(res2)) {
4614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4615 }
4616 if (!argp2) {
4617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4618 }
4619 arg2 = reinterpret_cast< wxObject * >(argp2);
4620 {
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 {
4627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4628 }
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4636 PyObject *obj;
4637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4638 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4639 return SWIG_Py_Void();
4640 }
4641
4642 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 int arg2 ;
4646 void *argp1 = 0 ;
4647 int res1 = 0 ;
4648 int val2 ;
4649 int ecode2 = 0 ;
4650 PyObject *swig_obj[2] ;
4651
4652 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4654 if (!SWIG_IsOK(res1)) {
4655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4656 }
4657 arg1 = reinterpret_cast< wxSize * >(argp1);
4658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4659 if (!SWIG_IsOK(ecode2)) {
4660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4661 }
4662 arg2 = static_cast< int >(val2);
4663 if (arg1) (arg1)->x = arg2;
4664
4665 resultobj = SWIG_Py_Void();
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4673 PyObject *resultobj = 0;
4674 wxSize *arg1 = (wxSize *) 0 ;
4675 int result;
4676 void *argp1 = 0 ;
4677 int res1 = 0 ;
4678 PyObject *swig_obj[1] ;
4679
4680 if (!args) SWIG_fail;
4681 swig_obj[0] = args;
4682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4683 if (!SWIG_IsOK(res1)) {
4684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4685 }
4686 arg1 = reinterpret_cast< wxSize * >(argp1);
4687 result = (int) ((arg1)->x);
4688 resultobj = SWIG_From_int(static_cast< int >(result));
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696 PyObject *resultobj = 0;
4697 wxSize *arg1 = (wxSize *) 0 ;
4698 int arg2 ;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 int val2 ;
4702 int ecode2 = 0 ;
4703 PyObject *swig_obj[2] ;
4704
4705 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4709 }
4710 arg1 = reinterpret_cast< wxSize * >(argp1);
4711 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4712 if (!SWIG_IsOK(ecode2)) {
4713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4714 }
4715 arg2 = static_cast< int >(val2);
4716 if (arg1) (arg1)->y = arg2;
4717
4718 resultobj = SWIG_Py_Void();
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 int result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 PyObject *swig_obj[1] ;
4732
4733 if (!args) SWIG_fail;
4734 swig_obj[0] = args;
4735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4736 if (!SWIG_IsOK(res1)) {
4737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4738 }
4739 arg1 = reinterpret_cast< wxSize * >(argp1);
4740 result = (int) ((arg1)->y);
4741 resultobj = SWIG_From_int(static_cast< int >(result));
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4749 PyObject *resultobj = 0;
4750 int arg1 = (int) 0 ;
4751 int arg2 = (int) 0 ;
4752 wxSize *result = 0 ;
4753 int val1 ;
4754 int ecode1 = 0 ;
4755 int val2 ;
4756 int ecode2 = 0 ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char * kwnames[] = {
4760 (char *) "w",(char *) "h", NULL
4761 };
4762
4763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4764 if (obj0) {
4765 ecode1 = SWIG_AsVal_int(obj0, &val1);
4766 if (!SWIG_IsOK(ecode1)) {
4767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4768 }
4769 arg1 = static_cast< int >(val1);
4770 }
4771 if (obj1) {
4772 ecode2 = SWIG_AsVal_int(obj1, &val2);
4773 if (!SWIG_IsOK(ecode2)) {
4774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4775 }
4776 arg2 = static_cast< int >(val2);
4777 }
4778 {
4779 result = (wxSize *)new wxSize(arg1,arg2);
4780 if (PyErr_Occurred()) SWIG_fail;
4781 }
4782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4783 return resultobj;
4784 fail:
4785 return NULL;
4786 }
4787
4788
4789 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4790 PyObject *resultobj = 0;
4791 wxSize *arg1 = (wxSize *) 0 ;
4792 void *argp1 = 0 ;
4793 int res1 = 0 ;
4794 PyObject *swig_obj[1] ;
4795
4796 if (!args) SWIG_fail;
4797 swig_obj[0] = args;
4798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4799 if (!SWIG_IsOK(res1)) {
4800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4801 }
4802 arg1 = reinterpret_cast< wxSize * >(argp1);
4803 {
4804 delete arg1;
4805
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 resultobj = SWIG_Py_Void();
4809 return resultobj;
4810 fail:
4811 return NULL;
4812 }
4813
4814
4815 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4816 PyObject *resultobj = 0;
4817 wxSize *arg1 = (wxSize *) 0 ;
4818 PyObject *arg2 = (PyObject *) 0 ;
4819 bool result;
4820 void *argp1 = 0 ;
4821 int res1 = 0 ;
4822 PyObject * obj0 = 0 ;
4823 PyObject * obj1 = 0 ;
4824 char * kwnames[] = {
4825 (char *) "self",(char *) "other", NULL
4826 };
4827
4828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4830 if (!SWIG_IsOK(res1)) {
4831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4832 }
4833 arg1 = reinterpret_cast< wxSize * >(argp1);
4834 arg2 = obj1;
4835 {
4836 result = (bool)wxSize___eq__(arg1,arg2);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 {
4840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4841 }
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 wxSize *arg1 = (wxSize *) 0 ;
4851 PyObject *arg2 = (PyObject *) 0 ;
4852 bool result;
4853 void *argp1 = 0 ;
4854 int res1 = 0 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char * kwnames[] = {
4858 (char *) "self",(char *) "other", NULL
4859 };
4860
4861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4863 if (!SWIG_IsOK(res1)) {
4864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4865 }
4866 arg1 = reinterpret_cast< wxSize * >(argp1);
4867 arg2 = obj1;
4868 {
4869 result = (bool)wxSize___ne__(arg1,arg2);
4870 if (PyErr_Occurred()) SWIG_fail;
4871 }
4872 {
4873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4874 }
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 wxSize *arg1 = (wxSize *) 0 ;
4884 wxSize *arg2 = 0 ;
4885 wxSize result;
4886 void *argp1 = 0 ;
4887 int res1 = 0 ;
4888 wxSize temp2 ;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 char * kwnames[] = {
4892 (char *) "self",(char *) "sz", NULL
4893 };
4894
4895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4897 if (!SWIG_IsOK(res1)) {
4898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4899 }
4900 arg1 = reinterpret_cast< wxSize * >(argp1);
4901 {
4902 arg2 = &temp2;
4903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4904 }
4905 {
4906 result = (arg1)->operator +((wxSize const &)*arg2);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 wxSize *arg2 = 0 ;
4920 wxSize result;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 wxSize temp2 ;
4924 PyObject * obj0 = 0 ;
4925 PyObject * obj1 = 0 ;
4926 char * kwnames[] = {
4927 (char *) "self",(char *) "sz", NULL
4928 };
4929
4930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4932 if (!SWIG_IsOK(res1)) {
4933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4934 }
4935 arg1 = reinterpret_cast< wxSize * >(argp1);
4936 {
4937 arg2 = &temp2;
4938 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4939 }
4940 {
4941 result = (arg1)->operator -((wxSize const &)*arg2);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4945 return resultobj;
4946 fail:
4947 return NULL;
4948 }
4949
4950
4951 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4952 PyObject *resultobj = 0;
4953 wxSize *arg1 = (wxSize *) 0 ;
4954 wxSize *arg2 = 0 ;
4955 void *argp1 = 0 ;
4956 int res1 = 0 ;
4957 wxSize temp2 ;
4958 PyObject * obj0 = 0 ;
4959 PyObject * obj1 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "sz", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4968 }
4969 arg1 = reinterpret_cast< wxSize * >(argp1);
4970 {
4971 arg2 = &temp2;
4972 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4973 }
4974 {
4975 (arg1)->IncTo((wxSize const &)*arg2);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 resultobj = SWIG_Py_Void();
4979 return resultobj;
4980 fail:
4981 return NULL;
4982 }
4983
4984
4985 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4986 PyObject *resultobj = 0;
4987 wxSize *arg1 = (wxSize *) 0 ;
4988 wxSize *arg2 = 0 ;
4989 void *argp1 = 0 ;
4990 int res1 = 0 ;
4991 wxSize temp2 ;
4992 PyObject * obj0 = 0 ;
4993 PyObject * obj1 = 0 ;
4994 char * kwnames[] = {
4995 (char *) "self",(char *) "sz", NULL
4996 };
4997
4998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5000 if (!SWIG_IsOK(res1)) {
5001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5002 }
5003 arg1 = reinterpret_cast< wxSize * >(argp1);
5004 {
5005 arg2 = &temp2;
5006 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5007 }
5008 {
5009 (arg1)->DecTo((wxSize const &)*arg2);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_Py_Void();
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5020 PyObject *resultobj = 0;
5021 wxSize *arg1 = (wxSize *) 0 ;
5022 int arg2 ;
5023 int arg3 ;
5024 void *argp1 = 0 ;
5025 int res1 = 0 ;
5026 int val2 ;
5027 int ecode2 = 0 ;
5028 int val3 ;
5029 int ecode3 = 0 ;
5030 PyObject * obj0 = 0 ;
5031 PyObject * obj1 = 0 ;
5032 PyObject * obj2 = 0 ;
5033 char * kwnames[] = {
5034 (char *) "self",(char *) "dx",(char *) "dy", NULL
5035 };
5036
5037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5039 if (!SWIG_IsOK(res1)) {
5040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5041 }
5042 arg1 = reinterpret_cast< wxSize * >(argp1);
5043 ecode2 = SWIG_AsVal_int(obj1, &val2);
5044 if (!SWIG_IsOK(ecode2)) {
5045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5046 }
5047 arg2 = static_cast< int >(val2);
5048 ecode3 = SWIG_AsVal_int(obj2, &val3);
5049 if (!SWIG_IsOK(ecode3)) {
5050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5051 }
5052 arg3 = static_cast< int >(val3);
5053 {
5054 (arg1)->IncBy(arg2,arg3);
5055 if (PyErr_Occurred()) SWIG_fail;
5056 }
5057 resultobj = SWIG_Py_Void();
5058 return resultobj;
5059 fail:
5060 return NULL;
5061 }
5062
5063
5064 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5065 PyObject *resultobj = 0;
5066 wxSize *arg1 = (wxSize *) 0 ;
5067 int arg2 ;
5068 int arg3 ;
5069 void *argp1 = 0 ;
5070 int res1 = 0 ;
5071 int val2 ;
5072 int ecode2 = 0 ;
5073 int val3 ;
5074 int ecode3 = 0 ;
5075 PyObject * obj0 = 0 ;
5076 PyObject * obj1 = 0 ;
5077 PyObject * obj2 = 0 ;
5078 char * kwnames[] = {
5079 (char *) "self",(char *) "dx",(char *) "dy", NULL
5080 };
5081
5082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5084 if (!SWIG_IsOK(res1)) {
5085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5086 }
5087 arg1 = reinterpret_cast< wxSize * >(argp1);
5088 ecode2 = SWIG_AsVal_int(obj1, &val2);
5089 if (!SWIG_IsOK(ecode2)) {
5090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5091 }
5092 arg2 = static_cast< int >(val2);
5093 ecode3 = SWIG_AsVal_int(obj2, &val3);
5094 if (!SWIG_IsOK(ecode3)) {
5095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5096 }
5097 arg3 = static_cast< int >(val3);
5098 {
5099 (arg1)->DecBy(arg2,arg3);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 resultobj = SWIG_Py_Void();
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5110 PyObject *resultobj = 0;
5111 wxSize *arg1 = (wxSize *) 0 ;
5112 float arg2 ;
5113 float arg3 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 float val2 ;
5117 int ecode2 = 0 ;
5118 float val3 ;
5119 int ecode3 = 0 ;
5120 PyObject * obj0 = 0 ;
5121 PyObject * obj1 = 0 ;
5122 PyObject * obj2 = 0 ;
5123 char * kwnames[] = {
5124 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5125 };
5126
5127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5129 if (!SWIG_IsOK(res1)) {
5130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5131 }
5132 arg1 = reinterpret_cast< wxSize * >(argp1);
5133 ecode2 = SWIG_AsVal_float(obj1, &val2);
5134 if (!SWIG_IsOK(ecode2)) {
5135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5136 }
5137 arg2 = static_cast< float >(val2);
5138 ecode3 = SWIG_AsVal_float(obj2, &val3);
5139 if (!SWIG_IsOK(ecode3)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5141 }
5142 arg3 = static_cast< float >(val3);
5143 {
5144 (arg1)->Scale(arg2,arg3);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 resultobj = SWIG_Py_Void();
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5155 PyObject *resultobj = 0;
5156 wxSize *arg1 = (wxSize *) 0 ;
5157 int arg2 ;
5158 int arg3 ;
5159 void *argp1 = 0 ;
5160 int res1 = 0 ;
5161 int val2 ;
5162 int ecode2 = 0 ;
5163 int val3 ;
5164 int ecode3 = 0 ;
5165 PyObject * obj0 = 0 ;
5166 PyObject * obj1 = 0 ;
5167 PyObject * obj2 = 0 ;
5168 char * kwnames[] = {
5169 (char *) "self",(char *) "w",(char *) "h", NULL
5170 };
5171
5172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5176 }
5177 arg1 = reinterpret_cast< wxSize * >(argp1);
5178 ecode2 = SWIG_AsVal_int(obj1, &val2);
5179 if (!SWIG_IsOK(ecode2)) {
5180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5181 }
5182 arg2 = static_cast< int >(val2);
5183 ecode3 = SWIG_AsVal_int(obj2, &val3);
5184 if (!SWIG_IsOK(ecode3)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5186 }
5187 arg3 = static_cast< int >(val3);
5188 {
5189 (arg1)->Set(arg2,arg3);
5190 if (PyErr_Occurred()) SWIG_fail;
5191 }
5192 resultobj = SWIG_Py_Void();
5193 return resultobj;
5194 fail:
5195 return NULL;
5196 }
5197
5198
5199 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5200 PyObject *resultobj = 0;
5201 wxSize *arg1 = (wxSize *) 0 ;
5202 int arg2 ;
5203 void *argp1 = 0 ;
5204 int res1 = 0 ;
5205 int val2 ;
5206 int ecode2 = 0 ;
5207 PyObject * obj0 = 0 ;
5208 PyObject * obj1 = 0 ;
5209 char * kwnames[] = {
5210 (char *) "self",(char *) "w", NULL
5211 };
5212
5213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5215 if (!SWIG_IsOK(res1)) {
5216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5217 }
5218 arg1 = reinterpret_cast< wxSize * >(argp1);
5219 ecode2 = SWIG_AsVal_int(obj1, &val2);
5220 if (!SWIG_IsOK(ecode2)) {
5221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5222 }
5223 arg2 = static_cast< int >(val2);
5224 {
5225 (arg1)->SetWidth(arg2);
5226 if (PyErr_Occurred()) SWIG_fail;
5227 }
5228 resultobj = SWIG_Py_Void();
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj = 0;
5237 wxSize *arg1 = (wxSize *) 0 ;
5238 int arg2 ;
5239 void *argp1 = 0 ;
5240 int res1 = 0 ;
5241 int val2 ;
5242 int ecode2 = 0 ;
5243 PyObject * obj0 = 0 ;
5244 PyObject * obj1 = 0 ;
5245 char * kwnames[] = {
5246 (char *) "self",(char *) "h", NULL
5247 };
5248
5249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5251 if (!SWIG_IsOK(res1)) {
5252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5253 }
5254 arg1 = reinterpret_cast< wxSize * >(argp1);
5255 ecode2 = SWIG_AsVal_int(obj1, &val2);
5256 if (!SWIG_IsOK(ecode2)) {
5257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5258 }
5259 arg2 = static_cast< int >(val2);
5260 {
5261 (arg1)->SetHeight(arg2);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_Py_Void();
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5272 PyObject *resultobj = 0;
5273 wxSize *arg1 = (wxSize *) 0 ;
5274 int result;
5275 void *argp1 = 0 ;
5276 int res1 = 0 ;
5277 PyObject *swig_obj[1] ;
5278
5279 if (!args) SWIG_fail;
5280 swig_obj[0] = args;
5281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5282 if (!SWIG_IsOK(res1)) {
5283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5284 }
5285 arg1 = reinterpret_cast< wxSize * >(argp1);
5286 {
5287 result = (int)((wxSize const *)arg1)->GetWidth();
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 resultobj = SWIG_From_int(static_cast< int >(result));
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 PyObject *resultobj = 0;
5299 wxSize *arg1 = (wxSize *) 0 ;
5300 int result;
5301 void *argp1 = 0 ;
5302 int res1 = 0 ;
5303 PyObject *swig_obj[1] ;
5304
5305 if (!args) SWIG_fail;
5306 swig_obj[0] = args;
5307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5308 if (!SWIG_IsOK(res1)) {
5309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5310 }
5311 arg1 = reinterpret_cast< wxSize * >(argp1);
5312 {
5313 result = (int)((wxSize const *)arg1)->GetHeight();
5314 if (PyErr_Occurred()) SWIG_fail;
5315 }
5316 resultobj = SWIG_From_int(static_cast< int >(result));
5317 return resultobj;
5318 fail:
5319 return NULL;
5320 }
5321
5322
5323 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5324 PyObject *resultobj = 0;
5325 wxSize *arg1 = (wxSize *) 0 ;
5326 bool result;
5327 void *argp1 = 0 ;
5328 int res1 = 0 ;
5329 PyObject *swig_obj[1] ;
5330
5331 if (!args) SWIG_fail;
5332 swig_obj[0] = args;
5333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5334 if (!SWIG_IsOK(res1)) {
5335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5336 }
5337 arg1 = reinterpret_cast< wxSize * >(argp1);
5338 {
5339 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 {
5343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5344 }
5345 return resultobj;
5346 fail:
5347 return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5352 PyObject *resultobj = 0;
5353 wxSize *arg1 = (wxSize *) 0 ;
5354 wxSize *arg2 = 0 ;
5355 void *argp1 = 0 ;
5356 int res1 = 0 ;
5357 wxSize temp2 ;
5358 PyObject * obj0 = 0 ;
5359 PyObject * obj1 = 0 ;
5360 char * kwnames[] = {
5361 (char *) "self",(char *) "size", NULL
5362 };
5363
5364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5366 if (!SWIG_IsOK(res1)) {
5367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5368 }
5369 arg1 = reinterpret_cast< wxSize * >(argp1);
5370 {
5371 arg2 = &temp2;
5372 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5373 }
5374 {
5375 (arg1)->SetDefaults((wxSize const &)*arg2);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 resultobj = SWIG_Py_Void();
5379 return resultobj;
5380 fail:
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5386 PyObject *resultobj = 0;
5387 wxSize *arg1 = (wxSize *) 0 ;
5388 PyObject *result = 0 ;
5389 void *argp1 = 0 ;
5390 int res1 = 0 ;
5391 PyObject *swig_obj[1] ;
5392
5393 if (!args) SWIG_fail;
5394 swig_obj[0] = args;
5395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5396 if (!SWIG_IsOK(res1)) {
5397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5398 }
5399 arg1 = reinterpret_cast< wxSize * >(argp1);
5400 {
5401 result = (PyObject *)wxSize_Get(arg1);
5402 if (PyErr_Occurred()) SWIG_fail;
5403 }
5404 resultobj = result;
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5412 PyObject *obj;
5413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5414 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5415 return SWIG_Py_Void();
5416 }
5417
5418 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5419 return SWIG_Python_InitShadowInstance(args);
5420 }
5421
5422 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5423 PyObject *resultobj = 0;
5424 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5425 double arg2 ;
5426 void *argp1 = 0 ;
5427 int res1 = 0 ;
5428 double val2 ;
5429 int ecode2 = 0 ;
5430 PyObject *swig_obj[2] ;
5431
5432 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5434 if (!SWIG_IsOK(res1)) {
5435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5436 }
5437 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5438 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5439 if (!SWIG_IsOK(ecode2)) {
5440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5441 }
5442 arg2 = static_cast< double >(val2);
5443 if (arg1) (arg1)->x = arg2;
5444
5445 resultobj = SWIG_Py_Void();
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453 PyObject *resultobj = 0;
5454 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5455 double result;
5456 void *argp1 = 0 ;
5457 int res1 = 0 ;
5458 PyObject *swig_obj[1] ;
5459
5460 if (!args) SWIG_fail;
5461 swig_obj[0] = args;
5462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5463 if (!SWIG_IsOK(res1)) {
5464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5465 }
5466 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5467 result = (double) ((arg1)->x);
5468 resultobj = SWIG_From_double(static_cast< double >(result));
5469 return resultobj;
5470 fail:
5471 return NULL;
5472 }
5473
5474
5475 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5476 PyObject *resultobj = 0;
5477 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5478 double arg2 ;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 double val2 ;
5482 int ecode2 = 0 ;
5483 PyObject *swig_obj[2] ;
5484
5485 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5487 if (!SWIG_IsOK(res1)) {
5488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5489 }
5490 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5491 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5492 if (!SWIG_IsOK(ecode2)) {
5493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5494 }
5495 arg2 = static_cast< double >(val2);
5496 if (arg1) (arg1)->y = arg2;
5497
5498 resultobj = SWIG_Py_Void();
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5506 PyObject *resultobj = 0;
5507 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5508 double result;
5509 void *argp1 = 0 ;
5510 int res1 = 0 ;
5511 PyObject *swig_obj[1] ;
5512
5513 if (!args) SWIG_fail;
5514 swig_obj[0] = args;
5515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5516 if (!SWIG_IsOK(res1)) {
5517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5518 }
5519 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5520 result = (double) ((arg1)->y);
5521 resultobj = SWIG_From_double(static_cast< double >(result));
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = 0;
5530 double arg1 = (double) 0.0 ;
5531 double arg2 = (double) 0.0 ;
5532 wxRealPoint *result = 0 ;
5533 double val1 ;
5534 int ecode1 = 0 ;
5535 double val2 ;
5536 int ecode2 = 0 ;
5537 PyObject * obj0 = 0 ;
5538 PyObject * obj1 = 0 ;
5539 char * kwnames[] = {
5540 (char *) "x",(char *) "y", NULL
5541 };
5542
5543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5544 if (obj0) {
5545 ecode1 = SWIG_AsVal_double(obj0, &val1);
5546 if (!SWIG_IsOK(ecode1)) {
5547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5548 }
5549 arg1 = static_cast< double >(val1);
5550 }
5551 if (obj1) {
5552 ecode2 = SWIG_AsVal_double(obj1, &val2);
5553 if (!SWIG_IsOK(ecode2)) {
5554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5555 }
5556 arg2 = static_cast< double >(val2);
5557 }
5558 {
5559 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5563 return resultobj;
5564 fail:
5565 return NULL;
5566 }
5567
5568
5569 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5570 PyObject *resultobj = 0;
5571 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5572 void *argp1 = 0 ;
5573 int res1 = 0 ;
5574 PyObject *swig_obj[1] ;
5575
5576 if (!args) SWIG_fail;
5577 swig_obj[0] = args;
5578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5579 if (!SWIG_IsOK(res1)) {
5580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5581 }
5582 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5583 {
5584 delete arg1;
5585
5586 if (PyErr_Occurred()) SWIG_fail;
5587 }
5588 resultobj = SWIG_Py_Void();
5589 return resultobj;
5590 fail:
5591 return NULL;
5592 }
5593
5594
5595 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj = 0;
5597 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5598 PyObject *arg2 = (PyObject *) 0 ;
5599 bool result;
5600 void *argp1 = 0 ;
5601 int res1 = 0 ;
5602 PyObject * obj0 = 0 ;
5603 PyObject * obj1 = 0 ;
5604 char * kwnames[] = {
5605 (char *) "self",(char *) "other", NULL
5606 };
5607
5608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5610 if (!SWIG_IsOK(res1)) {
5611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5612 }
5613 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5614 arg2 = obj1;
5615 {
5616 result = (bool)wxRealPoint___eq__(arg1,arg2);
5617 if (PyErr_Occurred()) SWIG_fail;
5618 }
5619 {
5620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5621 }
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
5628 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5629 PyObject *resultobj = 0;
5630 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5631 PyObject *arg2 = (PyObject *) 0 ;
5632 bool result;
5633 void *argp1 = 0 ;
5634 int res1 = 0 ;
5635 PyObject * obj0 = 0 ;
5636 PyObject * obj1 = 0 ;
5637 char * kwnames[] = {
5638 (char *) "self",(char *) "other", NULL
5639 };
5640
5641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5643 if (!SWIG_IsOK(res1)) {
5644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5645 }
5646 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5647 arg2 = obj1;
5648 {
5649 result = (bool)wxRealPoint___ne__(arg1,arg2);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 {
5653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5654 }
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5662 PyObject *resultobj = 0;
5663 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5664 wxRealPoint *arg2 = 0 ;
5665 wxRealPoint result;
5666 void *argp1 = 0 ;
5667 int res1 = 0 ;
5668 wxRealPoint temp2 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "self",(char *) "pt", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5681 {
5682 arg2 = &temp2;
5683 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5684 }
5685 {
5686 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5687 if (PyErr_Occurred()) SWIG_fail;
5688 }
5689 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5690 return resultobj;
5691 fail:
5692 return NULL;
5693 }
5694
5695
5696 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5697 PyObject *resultobj = 0;
5698 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5699 wxRealPoint *arg2 = 0 ;
5700 wxRealPoint result;
5701 void *argp1 = 0 ;
5702 int res1 = 0 ;
5703 wxRealPoint temp2 ;
5704 PyObject * obj0 = 0 ;
5705 PyObject * obj1 = 0 ;
5706 char * kwnames[] = {
5707 (char *) "self",(char *) "pt", NULL
5708 };
5709
5710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5712 if (!SWIG_IsOK(res1)) {
5713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5714 }
5715 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5716 {
5717 arg2 = &temp2;
5718 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5719 }
5720 {
5721 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5725 return resultobj;
5726 fail:
5727 return NULL;
5728 }
5729
5730
5731 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj = 0;
5733 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5734 double arg2 ;
5735 double arg3 ;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 double val2 ;
5739 int ecode2 = 0 ;
5740 double val3 ;
5741 int ecode3 = 0 ;
5742 PyObject * obj0 = 0 ;
5743 PyObject * obj1 = 0 ;
5744 PyObject * obj2 = 0 ;
5745 char * kwnames[] = {
5746 (char *) "self",(char *) "x",(char *) "y", NULL
5747 };
5748
5749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5755 ecode2 = SWIG_AsVal_double(obj1, &val2);
5756 if (!SWIG_IsOK(ecode2)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5758 }
5759 arg2 = static_cast< double >(val2);
5760 ecode3 = SWIG_AsVal_double(obj2, &val3);
5761 if (!SWIG_IsOK(ecode3)) {
5762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5763 }
5764 arg3 = static_cast< double >(val3);
5765 {
5766 wxRealPoint_Set(arg1,arg2,arg3);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 resultobj = SWIG_Py_Void();
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5777 PyObject *resultobj = 0;
5778 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5779 PyObject *result = 0 ;
5780 void *argp1 = 0 ;
5781 int res1 = 0 ;
5782 PyObject *swig_obj[1] ;
5783
5784 if (!args) SWIG_fail;
5785 swig_obj[0] = args;
5786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5787 if (!SWIG_IsOK(res1)) {
5788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5789 }
5790 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5791 {
5792 result = (PyObject *)wxRealPoint_Get(arg1);
5793 if (PyErr_Occurred()) SWIG_fail;
5794 }
5795 resultobj = result;
5796 return resultobj;
5797 fail:
5798 return NULL;
5799 }
5800
5801
5802 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5803 PyObject *obj;
5804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5805 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5806 return SWIG_Py_Void();
5807 }
5808
5809 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5810 return SWIG_Python_InitShadowInstance(args);
5811 }
5812
5813 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 int arg2 ;
5817 void *argp1 = 0 ;
5818 int res1 = 0 ;
5819 int val2 ;
5820 int ecode2 = 0 ;
5821 PyObject *swig_obj[2] ;
5822
5823 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5825 if (!SWIG_IsOK(res1)) {
5826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5827 }
5828 arg1 = reinterpret_cast< wxPoint * >(argp1);
5829 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5830 if (!SWIG_IsOK(ecode2)) {
5831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5832 }
5833 arg2 = static_cast< int >(val2);
5834 if (arg1) (arg1)->x = arg2;
5835
5836 resultobj = SWIG_Py_Void();
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5844 PyObject *resultobj = 0;
5845 wxPoint *arg1 = (wxPoint *) 0 ;
5846 int result;
5847 void *argp1 = 0 ;
5848 int res1 = 0 ;
5849 PyObject *swig_obj[1] ;
5850
5851 if (!args) SWIG_fail;
5852 swig_obj[0] = args;
5853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5854 if (!SWIG_IsOK(res1)) {
5855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5856 }
5857 arg1 = reinterpret_cast< wxPoint * >(argp1);
5858 result = (int) ((arg1)->x);
5859 resultobj = SWIG_From_int(static_cast< int >(result));
5860 return resultobj;
5861 fail:
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5867 PyObject *resultobj = 0;
5868 wxPoint *arg1 = (wxPoint *) 0 ;
5869 int arg2 ;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 int val2 ;
5873 int ecode2 = 0 ;
5874 PyObject *swig_obj[2] ;
5875
5876 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5878 if (!SWIG_IsOK(res1)) {
5879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5880 }
5881 arg1 = reinterpret_cast< wxPoint * >(argp1);
5882 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5883 if (!SWIG_IsOK(ecode2)) {
5884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5885 }
5886 arg2 = static_cast< int >(val2);
5887 if (arg1) (arg1)->y = arg2;
5888
5889 resultobj = SWIG_Py_Void();
5890 return resultobj;
5891 fail:
5892 return NULL;
5893 }
5894
5895
5896 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5897 PyObject *resultobj = 0;
5898 wxPoint *arg1 = (wxPoint *) 0 ;
5899 int result;
5900 void *argp1 = 0 ;
5901 int res1 = 0 ;
5902 PyObject *swig_obj[1] ;
5903
5904 if (!args) SWIG_fail;
5905 swig_obj[0] = args;
5906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5907 if (!SWIG_IsOK(res1)) {
5908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5909 }
5910 arg1 = reinterpret_cast< wxPoint * >(argp1);
5911 result = (int) ((arg1)->y);
5912 resultobj = SWIG_From_int(static_cast< int >(result));
5913 return resultobj;
5914 fail:
5915 return NULL;
5916 }
5917
5918
5919 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5920 PyObject *resultobj = 0;
5921 int arg1 = (int) 0 ;
5922 int arg2 = (int) 0 ;
5923 wxPoint *result = 0 ;
5924 int val1 ;
5925 int ecode1 = 0 ;
5926 int val2 ;
5927 int ecode2 = 0 ;
5928 PyObject * obj0 = 0 ;
5929 PyObject * obj1 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "x",(char *) "y", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5935 if (obj0) {
5936 ecode1 = SWIG_AsVal_int(obj0, &val1);
5937 if (!SWIG_IsOK(ecode1)) {
5938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5939 }
5940 arg1 = static_cast< int >(val1);
5941 }
5942 if (obj1) {
5943 ecode2 = SWIG_AsVal_int(obj1, &val2);
5944 if (!SWIG_IsOK(ecode2)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5946 }
5947 arg2 = static_cast< int >(val2);
5948 }
5949 {
5950 result = (wxPoint *)new wxPoint(arg1,arg2);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5961 PyObject *resultobj = 0;
5962 wxPoint *arg1 = (wxPoint *) 0 ;
5963 void *argp1 = 0 ;
5964 int res1 = 0 ;
5965 PyObject *swig_obj[1] ;
5966
5967 if (!args) SWIG_fail;
5968 swig_obj[0] = args;
5969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5970 if (!SWIG_IsOK(res1)) {
5971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5972 }
5973 arg1 = reinterpret_cast< wxPoint * >(argp1);
5974 {
5975 delete arg1;
5976
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 resultobj = SWIG_Py_Void();
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj = 0;
5988 wxPoint *arg1 = (wxPoint *) 0 ;
5989 PyObject *arg2 = (PyObject *) 0 ;
5990 bool result;
5991 void *argp1 = 0 ;
5992 int res1 = 0 ;
5993 PyObject * obj0 = 0 ;
5994 PyObject * obj1 = 0 ;
5995 char * kwnames[] = {
5996 (char *) "self",(char *) "other", NULL
5997 };
5998
5999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6001 if (!SWIG_IsOK(res1)) {
6002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6003 }
6004 arg1 = reinterpret_cast< wxPoint * >(argp1);
6005 arg2 = obj1;
6006 {
6007 result = (bool)wxPoint___eq__(arg1,arg2);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 {
6011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6012 }
6013 return resultobj;
6014 fail:
6015 return NULL;
6016 }
6017
6018
6019 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj = 0;
6021 wxPoint *arg1 = (wxPoint *) 0 ;
6022 PyObject *arg2 = (PyObject *) 0 ;
6023 bool result;
6024 void *argp1 = 0 ;
6025 int res1 = 0 ;
6026 PyObject * obj0 = 0 ;
6027 PyObject * obj1 = 0 ;
6028 char * kwnames[] = {
6029 (char *) "self",(char *) "other", NULL
6030 };
6031
6032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6034 if (!SWIG_IsOK(res1)) {
6035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6036 }
6037 arg1 = reinterpret_cast< wxPoint * >(argp1);
6038 arg2 = obj1;
6039 {
6040 result = (bool)wxPoint___ne__(arg1,arg2);
6041 if (PyErr_Occurred()) SWIG_fail;
6042 }
6043 {
6044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6045 }
6046 return resultobj;
6047 fail:
6048 return NULL;
6049 }
6050
6051
6052 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6053 PyObject *resultobj = 0;
6054 wxPoint *arg1 = (wxPoint *) 0 ;
6055 wxPoint *arg2 = 0 ;
6056 wxPoint result;
6057 void *argp1 = 0 ;
6058 int res1 = 0 ;
6059 wxPoint temp2 ;
6060 PyObject * obj0 = 0 ;
6061 PyObject * obj1 = 0 ;
6062 char * kwnames[] = {
6063 (char *) "self",(char *) "pt", NULL
6064 };
6065
6066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6068 if (!SWIG_IsOK(res1)) {
6069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6070 }
6071 arg1 = reinterpret_cast< wxPoint * >(argp1);
6072 {
6073 arg2 = &temp2;
6074 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6075 }
6076 {
6077 result = (arg1)->operator +((wxPoint const &)*arg2);
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 wxPoint *arg1 = (wxPoint *) 0 ;
6090 wxPoint *arg2 = 0 ;
6091 wxPoint result;
6092 void *argp1 = 0 ;
6093 int res1 = 0 ;
6094 wxPoint temp2 ;
6095 PyObject * obj0 = 0 ;
6096 PyObject * obj1 = 0 ;
6097 char * kwnames[] = {
6098 (char *) "self",(char *) "pt", NULL
6099 };
6100
6101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6105 }
6106 arg1 = reinterpret_cast< wxPoint * >(argp1);
6107 {
6108 arg2 = &temp2;
6109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6110 }
6111 {
6112 result = (arg1)->operator -((wxPoint const &)*arg2);
6113 if (PyErr_Occurred()) SWIG_fail;
6114 }
6115 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6116 return resultobj;
6117 fail:
6118 return NULL;
6119 }
6120
6121
6122 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6123 PyObject *resultobj = 0;
6124 wxPoint *arg1 = (wxPoint *) 0 ;
6125 wxPoint *arg2 = 0 ;
6126 wxPoint *result = 0 ;
6127 void *argp1 = 0 ;
6128 int res1 = 0 ;
6129 wxPoint temp2 ;
6130 PyObject * obj0 = 0 ;
6131 PyObject * obj1 = 0 ;
6132 char * kwnames[] = {
6133 (char *) "self",(char *) "pt", NULL
6134 };
6135
6136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6138 if (!SWIG_IsOK(res1)) {
6139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6140 }
6141 arg1 = reinterpret_cast< wxPoint * >(argp1);
6142 {
6143 arg2 = &temp2;
6144 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6145 }
6146 {
6147 {
6148 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6149 result = (wxPoint *) &_result_ref;
6150 }
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj = 0;
6162 wxPoint *arg1 = (wxPoint *) 0 ;
6163 wxPoint *arg2 = 0 ;
6164 wxPoint *result = 0 ;
6165 void *argp1 = 0 ;
6166 int res1 = 0 ;
6167 wxPoint temp2 ;
6168 PyObject * obj0 = 0 ;
6169 PyObject * obj1 = 0 ;
6170 char * kwnames[] = {
6171 (char *) "self",(char *) "pt", NULL
6172 };
6173
6174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6176 if (!SWIG_IsOK(res1)) {
6177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6178 }
6179 arg1 = reinterpret_cast< wxPoint * >(argp1);
6180 {
6181 arg2 = &temp2;
6182 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6183 }
6184 {
6185 {
6186 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6187 result = (wxPoint *) &_result_ref;
6188 }
6189 if (PyErr_Occurred()) SWIG_fail;
6190 }
6191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6192 return resultobj;
6193 fail:
6194 return NULL;
6195 }
6196
6197
6198 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6199 PyObject *resultobj = 0;
6200 wxPoint *arg1 = (wxPoint *) 0 ;
6201 long arg2 ;
6202 long arg3 ;
6203 void *argp1 = 0 ;
6204 int res1 = 0 ;
6205 long val2 ;
6206 int ecode2 = 0 ;
6207 long val3 ;
6208 int ecode3 = 0 ;
6209 PyObject * obj0 = 0 ;
6210 PyObject * obj1 = 0 ;
6211 PyObject * obj2 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "self",(char *) "x",(char *) "y", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6218 if (!SWIG_IsOK(res1)) {
6219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6220 }
6221 arg1 = reinterpret_cast< wxPoint * >(argp1);
6222 ecode2 = SWIG_AsVal_long(obj1, &val2);
6223 if (!SWIG_IsOK(ecode2)) {
6224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6225 }
6226 arg2 = static_cast< long >(val2);
6227 ecode3 = SWIG_AsVal_long(obj2, &val3);
6228 if (!SWIG_IsOK(ecode3)) {
6229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6230 }
6231 arg3 = static_cast< long >(val3);
6232 {
6233 wxPoint_Set(arg1,arg2,arg3);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 resultobj = SWIG_Py_Void();
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6244 PyObject *resultobj = 0;
6245 wxPoint *arg1 = (wxPoint *) 0 ;
6246 PyObject *result = 0 ;
6247 void *argp1 = 0 ;
6248 int res1 = 0 ;
6249 PyObject *swig_obj[1] ;
6250
6251 if (!args) SWIG_fail;
6252 swig_obj[0] = args;
6253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6254 if (!SWIG_IsOK(res1)) {
6255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6256 }
6257 arg1 = reinterpret_cast< wxPoint * >(argp1);
6258 {
6259 result = (PyObject *)wxPoint_Get(arg1);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = result;
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6270 PyObject *obj;
6271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6272 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6273 return SWIG_Py_Void();
6274 }
6275
6276 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6277 return SWIG_Python_InitShadowInstance(args);
6278 }
6279
6280 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj = 0;
6282 int arg1 = (int) 0 ;
6283 int arg2 = (int) 0 ;
6284 int arg3 = (int) 0 ;
6285 int arg4 = (int) 0 ;
6286 wxRect *result = 0 ;
6287 int val1 ;
6288 int ecode1 = 0 ;
6289 int val2 ;
6290 int ecode2 = 0 ;
6291 int val3 ;
6292 int ecode3 = 0 ;
6293 int val4 ;
6294 int ecode4 = 0 ;
6295 PyObject * obj0 = 0 ;
6296 PyObject * obj1 = 0 ;
6297 PyObject * obj2 = 0 ;
6298 PyObject * obj3 = 0 ;
6299 char * kwnames[] = {
6300 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6301 };
6302
6303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6304 if (obj0) {
6305 ecode1 = SWIG_AsVal_int(obj0, &val1);
6306 if (!SWIG_IsOK(ecode1)) {
6307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6308 }
6309 arg1 = static_cast< int >(val1);
6310 }
6311 if (obj1) {
6312 ecode2 = SWIG_AsVal_int(obj1, &val2);
6313 if (!SWIG_IsOK(ecode2)) {
6314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6315 }
6316 arg2 = static_cast< int >(val2);
6317 }
6318 if (obj2) {
6319 ecode3 = SWIG_AsVal_int(obj2, &val3);
6320 if (!SWIG_IsOK(ecode3)) {
6321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6322 }
6323 arg3 = static_cast< int >(val3);
6324 }
6325 if (obj3) {
6326 ecode4 = SWIG_AsVal_int(obj3, &val4);
6327 if (!SWIG_IsOK(ecode4)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6329 }
6330 arg4 = static_cast< int >(val4);
6331 }
6332 {
6333 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj = 0;
6345 wxPoint *arg1 = 0 ;
6346 wxPoint *arg2 = 0 ;
6347 wxRect *result = 0 ;
6348 wxPoint temp1 ;
6349 wxPoint temp2 ;
6350 PyObject * obj0 = 0 ;
6351 PyObject * obj1 = 0 ;
6352 char * kwnames[] = {
6353 (char *) "topLeft",(char *) "bottomRight", NULL
6354 };
6355
6356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6357 {
6358 arg1 = &temp1;
6359 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6360 }
6361 {
6362 arg2 = &temp2;
6363 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6364 }
6365 {
6366 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6367 if (PyErr_Occurred()) SWIG_fail;
6368 }
6369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj = 0;
6378 wxPoint *arg1 = 0 ;
6379 wxSize *arg2 = 0 ;
6380 wxRect *result = 0 ;
6381 wxPoint temp1 ;
6382 wxSize temp2 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 char * kwnames[] = {
6386 (char *) "pos",(char *) "size", NULL
6387 };
6388
6389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6390 {
6391 arg1 = &temp1;
6392 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6393 }
6394 {
6395 arg2 = &temp2;
6396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6397 }
6398 {
6399 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxSize *arg1 = 0 ;
6412 wxRect *result = 0 ;
6413 wxSize temp1 ;
6414 PyObject * obj0 = 0 ;
6415 char * kwnames[] = {
6416 (char *) "size", NULL
6417 };
6418
6419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6420 {
6421 arg1 = &temp1;
6422 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6423 }
6424 {
6425 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6436 PyObject *resultobj = 0;
6437 wxRect *arg1 = (wxRect *) 0 ;
6438 void *argp1 = 0 ;
6439 int res1 = 0 ;
6440 PyObject *swig_obj[1] ;
6441
6442 if (!args) SWIG_fail;
6443 swig_obj[0] = args;
6444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6445 if (!SWIG_IsOK(res1)) {
6446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6447 }
6448 arg1 = reinterpret_cast< wxRect * >(argp1);
6449 {
6450 delete arg1;
6451
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_Py_Void();
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6462 PyObject *resultobj = 0;
6463 wxRect *arg1 = (wxRect *) 0 ;
6464 int result;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 PyObject *swig_obj[1] ;
6468
6469 if (!args) SWIG_fail;
6470 swig_obj[0] = args;
6471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6474 }
6475 arg1 = reinterpret_cast< wxRect * >(argp1);
6476 {
6477 result = (int)((wxRect const *)arg1)->GetX();
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 resultobj = SWIG_From_int(static_cast< int >(result));
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj = 0;
6489 wxRect *arg1 = (wxRect *) 0 ;
6490 int arg2 ;
6491 void *argp1 = 0 ;
6492 int res1 = 0 ;
6493 int val2 ;
6494 int ecode2 = 0 ;
6495 PyObject * obj0 = 0 ;
6496 PyObject * obj1 = 0 ;
6497 char * kwnames[] = {
6498 (char *) "self",(char *) "x", NULL
6499 };
6500
6501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6503 if (!SWIG_IsOK(res1)) {
6504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6505 }
6506 arg1 = reinterpret_cast< wxRect * >(argp1);
6507 ecode2 = SWIG_AsVal_int(obj1, &val2);
6508 if (!SWIG_IsOK(ecode2)) {
6509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6510 }
6511 arg2 = static_cast< int >(val2);
6512 {
6513 (arg1)->SetX(arg2);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_Py_Void();
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6524 PyObject *resultobj = 0;
6525 wxRect *arg1 = (wxRect *) 0 ;
6526 int result;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 PyObject *swig_obj[1] ;
6530
6531 if (!args) SWIG_fail;
6532 swig_obj[0] = args;
6533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 {
6539 result = (int)(arg1)->GetY();
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 resultobj = SWIG_From_int(static_cast< int >(result));
6543 return resultobj;
6544 fail:
6545 return NULL;
6546 }
6547
6548
6549 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6550 PyObject *resultobj = 0;
6551 wxRect *arg1 = (wxRect *) 0 ;
6552 int arg2 ;
6553 void *argp1 = 0 ;
6554 int res1 = 0 ;
6555 int val2 ;
6556 int ecode2 = 0 ;
6557 PyObject * obj0 = 0 ;
6558 PyObject * obj1 = 0 ;
6559 char * kwnames[] = {
6560 (char *) "self",(char *) "y", NULL
6561 };
6562
6563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6565 if (!SWIG_IsOK(res1)) {
6566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6567 }
6568 arg1 = reinterpret_cast< wxRect * >(argp1);
6569 ecode2 = SWIG_AsVal_int(obj1, &val2);
6570 if (!SWIG_IsOK(ecode2)) {
6571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6572 }
6573 arg2 = static_cast< int >(val2);
6574 {
6575 (arg1)->SetY(arg2);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 resultobj = SWIG_Py_Void();
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6586 PyObject *resultobj = 0;
6587 wxRect *arg1 = (wxRect *) 0 ;
6588 int result;
6589 void *argp1 = 0 ;
6590 int res1 = 0 ;
6591 PyObject *swig_obj[1] ;
6592
6593 if (!args) SWIG_fail;
6594 swig_obj[0] = args;
6595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6596 if (!SWIG_IsOK(res1)) {
6597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6598 }
6599 arg1 = reinterpret_cast< wxRect * >(argp1);
6600 {
6601 result = (int)((wxRect const *)arg1)->GetWidth();
6602 if (PyErr_Occurred()) SWIG_fail;
6603 }
6604 resultobj = SWIG_From_int(static_cast< int >(result));
6605 return resultobj;
6606 fail:
6607 return NULL;
6608 }
6609
6610
6611 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6612 PyObject *resultobj = 0;
6613 wxRect *arg1 = (wxRect *) 0 ;
6614 int arg2 ;
6615 void *argp1 = 0 ;
6616 int res1 = 0 ;
6617 int val2 ;
6618 int ecode2 = 0 ;
6619 PyObject * obj0 = 0 ;
6620 PyObject * obj1 = 0 ;
6621 char * kwnames[] = {
6622 (char *) "self",(char *) "w", NULL
6623 };
6624
6625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6627 if (!SWIG_IsOK(res1)) {
6628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6629 }
6630 arg1 = reinterpret_cast< wxRect * >(argp1);
6631 ecode2 = SWIG_AsVal_int(obj1, &val2);
6632 if (!SWIG_IsOK(ecode2)) {
6633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6634 }
6635 arg2 = static_cast< int >(val2);
6636 {
6637 (arg1)->SetWidth(arg2);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 resultobj = SWIG_Py_Void();
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6648 PyObject *resultobj = 0;
6649 wxRect *arg1 = (wxRect *) 0 ;
6650 int result;
6651 void *argp1 = 0 ;
6652 int res1 = 0 ;
6653 PyObject *swig_obj[1] ;
6654
6655 if (!args) SWIG_fail;
6656 swig_obj[0] = args;
6657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6658 if (!SWIG_IsOK(res1)) {
6659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6660 }
6661 arg1 = reinterpret_cast< wxRect * >(argp1);
6662 {
6663 result = (int)((wxRect const *)arg1)->GetHeight();
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 resultobj = SWIG_From_int(static_cast< int >(result));
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
6673 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6674 PyObject *resultobj = 0;
6675 wxRect *arg1 = (wxRect *) 0 ;
6676 int arg2 ;
6677 void *argp1 = 0 ;
6678 int res1 = 0 ;
6679 int val2 ;
6680 int ecode2 = 0 ;
6681 PyObject * obj0 = 0 ;
6682 PyObject * obj1 = 0 ;
6683 char * kwnames[] = {
6684 (char *) "self",(char *) "h", NULL
6685 };
6686
6687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6689 if (!SWIG_IsOK(res1)) {
6690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6691 }
6692 arg1 = reinterpret_cast< wxRect * >(argp1);
6693 ecode2 = SWIG_AsVal_int(obj1, &val2);
6694 if (!SWIG_IsOK(ecode2)) {
6695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6696 }
6697 arg2 = static_cast< int >(val2);
6698 {
6699 (arg1)->SetHeight(arg2);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_Py_Void();
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6710 PyObject *resultobj = 0;
6711 wxRect *arg1 = (wxRect *) 0 ;
6712 wxPoint result;
6713 void *argp1 = 0 ;
6714 int res1 = 0 ;
6715 PyObject *swig_obj[1] ;
6716
6717 if (!args) SWIG_fail;
6718 swig_obj[0] = args;
6719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6720 if (!SWIG_IsOK(res1)) {
6721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6722 }
6723 arg1 = reinterpret_cast< wxRect * >(argp1);
6724 {
6725 result = ((wxRect const *)arg1)->GetPosition();
6726 if (PyErr_Occurred()) SWIG_fail;
6727 }
6728 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6729 return resultobj;
6730 fail:
6731 return NULL;
6732 }
6733
6734
6735 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6736 PyObject *resultobj = 0;
6737 wxRect *arg1 = (wxRect *) 0 ;
6738 wxPoint *arg2 = 0 ;
6739 void *argp1 = 0 ;
6740 int res1 = 0 ;
6741 wxPoint temp2 ;
6742 PyObject * obj0 = 0 ;
6743 PyObject * obj1 = 0 ;
6744 char * kwnames[] = {
6745 (char *) "self",(char *) "p", NULL
6746 };
6747
6748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6750 if (!SWIG_IsOK(res1)) {
6751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6752 }
6753 arg1 = reinterpret_cast< wxRect * >(argp1);
6754 {
6755 arg2 = &temp2;
6756 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6757 }
6758 {
6759 (arg1)->SetPosition((wxPoint const &)*arg2);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 resultobj = SWIG_Py_Void();
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 wxSize result;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 PyObject *swig_obj[1] ;
6776
6777 if (!args) SWIG_fail;
6778 swig_obj[0] = args;
6779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6780 if (!SWIG_IsOK(res1)) {
6781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6782 }
6783 arg1 = reinterpret_cast< wxRect * >(argp1);
6784 {
6785 result = ((wxRect const *)arg1)->GetSize();
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj = 0;
6797 wxRect *arg1 = (wxRect *) 0 ;
6798 wxSize *arg2 = 0 ;
6799 void *argp1 = 0 ;
6800 int res1 = 0 ;
6801 wxSize temp2 ;
6802 PyObject * obj0 = 0 ;
6803 PyObject * obj1 = 0 ;
6804 char * kwnames[] = {
6805 (char *) "self",(char *) "s", NULL
6806 };
6807
6808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6810 if (!SWIG_IsOK(res1)) {
6811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6812 }
6813 arg1 = reinterpret_cast< wxRect * >(argp1);
6814 {
6815 arg2 = &temp2;
6816 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6817 }
6818 {
6819 (arg1)->SetSize((wxSize const &)*arg2);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_Py_Void();
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 wxRect *arg1 = (wxRect *) 0 ;
6832 bool result;
6833 void *argp1 = 0 ;
6834 int res1 = 0 ;
6835 PyObject *swig_obj[1] ;
6836
6837 if (!args) SWIG_fail;
6838 swig_obj[0] = args;
6839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6840 if (!SWIG_IsOK(res1)) {
6841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6842 }
6843 arg1 = reinterpret_cast< wxRect * >(argp1);
6844 {
6845 result = (bool)((wxRect const *)arg1)->IsEmpty();
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 {
6849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6850 }
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6858 PyObject *resultobj = 0;
6859 wxRect *arg1 = (wxRect *) 0 ;
6860 wxPoint result;
6861 void *argp1 = 0 ;
6862 int res1 = 0 ;
6863 PyObject *swig_obj[1] ;
6864
6865 if (!args) SWIG_fail;
6866 swig_obj[0] = args;
6867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6868 if (!SWIG_IsOK(res1)) {
6869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6870 }
6871 arg1 = reinterpret_cast< wxRect * >(argp1);
6872 {
6873 result = ((wxRect const *)arg1)->GetTopLeft();
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 wxPoint *arg2 = 0 ;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 wxPoint temp2 ;
6890 PyObject * obj0 = 0 ;
6891 PyObject * obj1 = 0 ;
6892 char * kwnames[] = {
6893 (char *) "self",(char *) "p", NULL
6894 };
6895
6896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6898 if (!SWIG_IsOK(res1)) {
6899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6900 }
6901 arg1 = reinterpret_cast< wxRect * >(argp1);
6902 {
6903 arg2 = &temp2;
6904 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6905 }
6906 {
6907 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_Py_Void();
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6918 PyObject *resultobj = 0;
6919 wxRect *arg1 = (wxRect *) 0 ;
6920 wxPoint result;
6921 void *argp1 = 0 ;
6922 int res1 = 0 ;
6923 PyObject *swig_obj[1] ;
6924
6925 if (!args) SWIG_fail;
6926 swig_obj[0] = args;
6927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6928 if (!SWIG_IsOK(res1)) {
6929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6930 }
6931 arg1 = reinterpret_cast< wxRect * >(argp1);
6932 {
6933 result = ((wxRect const *)arg1)->GetBottomRight();
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj = 0;
6945 wxRect *arg1 = (wxRect *) 0 ;
6946 wxPoint *arg2 = 0 ;
6947 void *argp1 = 0 ;
6948 int res1 = 0 ;
6949 wxPoint temp2 ;
6950 PyObject * obj0 = 0 ;
6951 PyObject * obj1 = 0 ;
6952 char * kwnames[] = {
6953 (char *) "self",(char *) "p", NULL
6954 };
6955
6956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6958 if (!SWIG_IsOK(res1)) {
6959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6960 }
6961 arg1 = reinterpret_cast< wxRect * >(argp1);
6962 {
6963 arg2 = &temp2;
6964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6965 }
6966 {
6967 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 wxPoint result;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 PyObject *swig_obj[1] ;
6984
6985 if (!args) SWIG_fail;
6986 swig_obj[0] = args;
6987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6988 if (!SWIG_IsOK(res1)) {
6989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6990 }
6991 arg1 = reinterpret_cast< wxRect * >(argp1);
6992 {
6993 result = ((wxRect const *)arg1)->GetTopRight();
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7004 PyObject *resultobj = 0;
7005 wxRect *arg1 = (wxRect *) 0 ;
7006 wxPoint *arg2 = 0 ;
7007 void *argp1 = 0 ;
7008 int res1 = 0 ;
7009 wxPoint temp2 ;
7010 PyObject * obj0 = 0 ;
7011 PyObject * obj1 = 0 ;
7012 char * kwnames[] = {
7013 (char *) "self",(char *) "p", NULL
7014 };
7015
7016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7018 if (!SWIG_IsOK(res1)) {
7019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7020 }
7021 arg1 = reinterpret_cast< wxRect * >(argp1);
7022 {
7023 arg2 = &temp2;
7024 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7025 }
7026 {
7027 (arg1)->SetTopRight((wxPoint const &)*arg2);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 resultobj = SWIG_Py_Void();
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7038 PyObject *resultobj = 0;
7039 wxRect *arg1 = (wxRect *) 0 ;
7040 wxPoint result;
7041 void *argp1 = 0 ;
7042 int res1 = 0 ;
7043 PyObject *swig_obj[1] ;
7044
7045 if (!args) SWIG_fail;
7046 swig_obj[0] = args;
7047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7048 if (!SWIG_IsOK(res1)) {
7049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7050 }
7051 arg1 = reinterpret_cast< wxRect * >(argp1);
7052 {
7053 result = ((wxRect const *)arg1)->GetBottomLeft();
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj = 0;
7065 wxRect *arg1 = (wxRect *) 0 ;
7066 wxPoint *arg2 = 0 ;
7067 void *argp1 = 0 ;
7068 int res1 = 0 ;
7069 wxPoint temp2 ;
7070 PyObject * obj0 = 0 ;
7071 PyObject * obj1 = 0 ;
7072 char * kwnames[] = {
7073 (char *) "self",(char *) "p", NULL
7074 };
7075
7076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7078 if (!SWIG_IsOK(res1)) {
7079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7080 }
7081 arg1 = reinterpret_cast< wxRect * >(argp1);
7082 {
7083 arg2 = &temp2;
7084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7085 }
7086 {
7087 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 resultobj = SWIG_Py_Void();
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098 PyObject *resultobj = 0;
7099 wxRect *arg1 = (wxRect *) 0 ;
7100 int result;
7101 void *argp1 = 0 ;
7102 int res1 = 0 ;
7103 PyObject *swig_obj[1] ;
7104
7105 if (!args) SWIG_fail;
7106 swig_obj[0] = args;
7107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7108 if (!SWIG_IsOK(res1)) {
7109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7110 }
7111 arg1 = reinterpret_cast< wxRect * >(argp1);
7112 {
7113 result = (int)((wxRect const *)arg1)->GetLeft();
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_From_int(static_cast< int >(result));
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int result;
7127 void *argp1 = 0 ;
7128 int res1 = 0 ;
7129 PyObject *swig_obj[1] ;
7130
7131 if (!args) SWIG_fail;
7132 swig_obj[0] = args;
7133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7134 if (!SWIG_IsOK(res1)) {
7135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7136 }
7137 arg1 = reinterpret_cast< wxRect * >(argp1);
7138 {
7139 result = (int)((wxRect const *)arg1)->GetTop();
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 resultobj = SWIG_From_int(static_cast< int >(result));
7143 return resultobj;
7144 fail:
7145 return NULL;
7146 }
7147
7148
7149 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7150 PyObject *resultobj = 0;
7151 wxRect *arg1 = (wxRect *) 0 ;
7152 int result;
7153 void *argp1 = 0 ;
7154 int res1 = 0 ;
7155 PyObject *swig_obj[1] ;
7156
7157 if (!args) SWIG_fail;
7158 swig_obj[0] = args;
7159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7160 if (!SWIG_IsOK(res1)) {
7161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7162 }
7163 arg1 = reinterpret_cast< wxRect * >(argp1);
7164 {
7165 result = (int)((wxRect const *)arg1)->GetBottom();
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_From_int(static_cast< int >(result));
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7176 PyObject *resultobj = 0;
7177 wxRect *arg1 = (wxRect *) 0 ;
7178 int result;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 PyObject *swig_obj[1] ;
7182
7183 if (!args) SWIG_fail;
7184 swig_obj[0] = args;
7185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7186 if (!SWIG_IsOK(res1)) {
7187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7188 }
7189 arg1 = reinterpret_cast< wxRect * >(argp1);
7190 {
7191 result = (int)((wxRect const *)arg1)->GetRight();
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 resultobj = SWIG_From_int(static_cast< int >(result));
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7202 PyObject *resultobj = 0;
7203 wxRect *arg1 = (wxRect *) 0 ;
7204 int arg2 ;
7205 void *argp1 = 0 ;
7206 int res1 = 0 ;
7207 int val2 ;
7208 int ecode2 = 0 ;
7209 PyObject * obj0 = 0 ;
7210 PyObject * obj1 = 0 ;
7211 char * kwnames[] = {
7212 (char *) "self",(char *) "left", NULL
7213 };
7214
7215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7217 if (!SWIG_IsOK(res1)) {
7218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7219 }
7220 arg1 = reinterpret_cast< wxRect * >(argp1);
7221 ecode2 = SWIG_AsVal_int(obj1, &val2);
7222 if (!SWIG_IsOK(ecode2)) {
7223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7224 }
7225 arg2 = static_cast< int >(val2);
7226 {
7227 (arg1)->SetLeft(arg2);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 resultobj = SWIG_Py_Void();
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj = 0;
7239 wxRect *arg1 = (wxRect *) 0 ;
7240 int arg2 ;
7241 void *argp1 = 0 ;
7242 int res1 = 0 ;
7243 int val2 ;
7244 int ecode2 = 0 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 char * kwnames[] = {
7248 (char *) "self",(char *) "right", NULL
7249 };
7250
7251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7253 if (!SWIG_IsOK(res1)) {
7254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7255 }
7256 arg1 = reinterpret_cast< wxRect * >(argp1);
7257 ecode2 = SWIG_AsVal_int(obj1, &val2);
7258 if (!SWIG_IsOK(ecode2)) {
7259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7260 }
7261 arg2 = static_cast< int >(val2);
7262 {
7263 (arg1)->SetRight(arg2);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_Py_Void();
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj = 0;
7275 wxRect *arg1 = (wxRect *) 0 ;
7276 int arg2 ;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 int val2 ;
7280 int ecode2 = 0 ;
7281 PyObject * obj0 = 0 ;
7282 PyObject * obj1 = 0 ;
7283 char * kwnames[] = {
7284 (char *) "self",(char *) "top", NULL
7285 };
7286
7287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7289 if (!SWIG_IsOK(res1)) {
7290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7291 }
7292 arg1 = reinterpret_cast< wxRect * >(argp1);
7293 ecode2 = SWIG_AsVal_int(obj1, &val2);
7294 if (!SWIG_IsOK(ecode2)) {
7295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7296 }
7297 arg2 = static_cast< int >(val2);
7298 {
7299 (arg1)->SetTop(arg2);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 resultobj = SWIG_Py_Void();
7303 return resultobj;
7304 fail:
7305 return NULL;
7306 }
7307
7308
7309 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7310 PyObject *resultobj = 0;
7311 wxRect *arg1 = (wxRect *) 0 ;
7312 int arg2 ;
7313 void *argp1 = 0 ;
7314 int res1 = 0 ;
7315 int val2 ;
7316 int ecode2 = 0 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 char * kwnames[] = {
7320 (char *) "self",(char *) "bottom", NULL
7321 };
7322
7323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7325 if (!SWIG_IsOK(res1)) {
7326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7327 }
7328 arg1 = reinterpret_cast< wxRect * >(argp1);
7329 ecode2 = SWIG_AsVal_int(obj1, &val2);
7330 if (!SWIG_IsOK(ecode2)) {
7331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7332 }
7333 arg2 = static_cast< int >(val2);
7334 {
7335 (arg1)->SetBottom(arg2);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 resultobj = SWIG_Py_Void();
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj = 0;
7347 wxRect *arg1 = (wxRect *) 0 ;
7348 int arg2 ;
7349 int arg3 ;
7350 wxRect result;
7351 void *argp1 = 0 ;
7352 int res1 = 0 ;
7353 int val2 ;
7354 int ecode2 = 0 ;
7355 int val3 ;
7356 int ecode3 = 0 ;
7357 PyObject * obj0 = 0 ;
7358 PyObject * obj1 = 0 ;
7359 PyObject * obj2 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "dx",(char *) "dy", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 ecode2 = SWIG_AsVal_int(obj1, &val2);
7371 if (!SWIG_IsOK(ecode2)) {
7372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7373 }
7374 arg2 = static_cast< int >(val2);
7375 ecode3 = SWIG_AsVal_int(obj2, &val3);
7376 if (!SWIG_IsOK(ecode3)) {
7377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7378 }
7379 arg3 = static_cast< int >(val3);
7380 {
7381 result = (arg1)->Inflate(arg2,arg3);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj = 0;
7393 wxRect *arg1 = (wxRect *) 0 ;
7394 int arg2 ;
7395 int arg3 ;
7396 wxRect *result = 0 ;
7397 void *argp1 = 0 ;
7398 int res1 = 0 ;
7399 int val2 ;
7400 int ecode2 = 0 ;
7401 int val3 ;
7402 int ecode3 = 0 ;
7403 PyObject * obj0 = 0 ;
7404 PyObject * obj1 = 0 ;
7405 PyObject * obj2 = 0 ;
7406 char * kwnames[] = {
7407 (char *) "self",(char *) "dx",(char *) "dy", NULL
7408 };
7409
7410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7412 if (!SWIG_IsOK(res1)) {
7413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7414 }
7415 arg1 = reinterpret_cast< wxRect * >(argp1);
7416 ecode2 = SWIG_AsVal_int(obj1, &val2);
7417 if (!SWIG_IsOK(ecode2)) {
7418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7419 }
7420 arg2 = static_cast< int >(val2);
7421 ecode3 = SWIG_AsVal_int(obj2, &val3);
7422 if (!SWIG_IsOK(ecode3)) {
7423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7424 }
7425 arg3 = static_cast< int >(val3);
7426 {
7427 {
7428 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7429 result = (wxRect *) &_result_ref;
7430 }
7431 if (PyErr_Occurred()) SWIG_fail;
7432 }
7433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7434 return resultobj;
7435 fail:
7436 return NULL;
7437 }
7438
7439
7440 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7441 PyObject *resultobj = 0;
7442 wxRect *arg1 = (wxRect *) 0 ;
7443 int arg2 ;
7444 int arg3 ;
7445 void *argp1 = 0 ;
7446 int res1 = 0 ;
7447 int val2 ;
7448 int ecode2 = 0 ;
7449 int val3 ;
7450 int ecode3 = 0 ;
7451 PyObject * obj0 = 0 ;
7452 PyObject * obj1 = 0 ;
7453 PyObject * obj2 = 0 ;
7454 char * kwnames[] = {
7455 (char *) "self",(char *) "dx",(char *) "dy", NULL
7456 };
7457
7458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7460 if (!SWIG_IsOK(res1)) {
7461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7462 }
7463 arg1 = reinterpret_cast< wxRect * >(argp1);
7464 ecode2 = SWIG_AsVal_int(obj1, &val2);
7465 if (!SWIG_IsOK(ecode2)) {
7466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7467 }
7468 arg2 = static_cast< int >(val2);
7469 ecode3 = SWIG_AsVal_int(obj2, &val3);
7470 if (!SWIG_IsOK(ecode3)) {
7471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7472 }
7473 arg3 = static_cast< int >(val3);
7474 {
7475 (arg1)->Offset(arg2,arg3);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 resultobj = SWIG_Py_Void();
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxRect *arg1 = (wxRect *) 0 ;
7488 wxPoint *arg2 = 0 ;
7489 void *argp1 = 0 ;
7490 int res1 = 0 ;
7491 wxPoint temp2 ;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char * kwnames[] = {
7495 (char *) "self",(char *) "pt", NULL
7496 };
7497
7498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7500 if (!SWIG_IsOK(res1)) {
7501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7502 }
7503 arg1 = reinterpret_cast< wxRect * >(argp1);
7504 {
7505 arg2 = &temp2;
7506 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7507 }
7508 {
7509 (arg1)->Offset((wxPoint const &)*arg2);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 resultobj = SWIG_Py_Void();
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7520 PyObject *resultobj = 0;
7521 wxRect *arg1 = (wxRect *) 0 ;
7522 wxRect *arg2 = 0 ;
7523 wxRect result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 wxRect temp2 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char * kwnames[] = {
7530 (char *) "self",(char *) "rect", NULL
7531 };
7532
7533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7537 }
7538 arg1 = reinterpret_cast< wxRect * >(argp1);
7539 {
7540 arg2 = &temp2;
7541 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7542 }
7543 {
7544 result = (arg1)->Intersect((wxRect const &)*arg2);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxRect *arg1 = (wxRect *) 0 ;
7557 wxRect *arg2 = 0 ;
7558 wxRect result;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 wxRect temp2 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "rect", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 {
7575 arg2 = &temp2;
7576 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7577 }
7578 {
7579 result = (arg1)->Union((wxRect const &)*arg2);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = 0;
7591 wxRect *arg1 = (wxRect *) 0 ;
7592 wxRect *arg2 = 0 ;
7593 wxRect result;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 wxRect temp2 ;
7597 PyObject * obj0 = 0 ;
7598 PyObject * obj1 = 0 ;
7599 char * kwnames[] = {
7600 (char *) "self",(char *) "rect", NULL
7601 };
7602
7603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7605 if (!SWIG_IsOK(res1)) {
7606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 {
7610 arg2 = &temp2;
7611 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7612 }
7613 {
7614 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7615 if (PyErr_Occurred()) SWIG_fail;
7616 }
7617 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj = 0;
7626 wxRect *arg1 = (wxRect *) 0 ;
7627 wxRect *arg2 = 0 ;
7628 wxRect *result = 0 ;
7629 void *argp1 = 0 ;
7630 int res1 = 0 ;
7631 wxRect temp2 ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char * kwnames[] = {
7635 (char *) "self",(char *) "rect", NULL
7636 };
7637
7638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 {
7645 arg2 = &temp2;
7646 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7647 }
7648 {
7649 {
7650 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7651 result = (wxRect *) &_result_ref;
7652 }
7653 if (PyErr_Occurred()) SWIG_fail;
7654 }
7655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = 0;
7664 wxRect *arg1 = (wxRect *) 0 ;
7665 PyObject *arg2 = (PyObject *) 0 ;
7666 bool result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 PyObject * obj0 = 0 ;
7670 PyObject * obj1 = 0 ;
7671 char * kwnames[] = {
7672 (char *) "self",(char *) "other", NULL
7673 };
7674
7675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7677 if (!SWIG_IsOK(res1)) {
7678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7679 }
7680 arg1 = reinterpret_cast< wxRect * >(argp1);
7681 arg2 = obj1;
7682 {
7683 result = (bool)wxRect___eq__(arg1,arg2);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 {
7687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7688 }
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj = 0;
7697 wxRect *arg1 = (wxRect *) 0 ;
7698 PyObject *arg2 = (PyObject *) 0 ;
7699 bool result;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 PyObject * obj0 = 0 ;
7703 PyObject * obj1 = 0 ;
7704 char * kwnames[] = {
7705 (char *) "self",(char *) "other", NULL
7706 };
7707
7708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7710 if (!SWIG_IsOK(res1)) {
7711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7712 }
7713 arg1 = reinterpret_cast< wxRect * >(argp1);
7714 arg2 = obj1;
7715 {
7716 result = (bool)wxRect___ne__(arg1,arg2);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 {
7720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7721 }
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj = 0;
7730 wxRect *arg1 = (wxRect *) 0 ;
7731 int arg2 ;
7732 int arg3 ;
7733 bool result;
7734 void *argp1 = 0 ;
7735 int res1 = 0 ;
7736 int val2 ;
7737 int ecode2 = 0 ;
7738 int val3 ;
7739 int ecode3 = 0 ;
7740 PyObject * obj0 = 0 ;
7741 PyObject * obj1 = 0 ;
7742 PyObject * obj2 = 0 ;
7743 char * kwnames[] = {
7744 (char *) "self",(char *) "x",(char *) "y", NULL
7745 };
7746
7747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 ecode2 = SWIG_AsVal_int(obj1, &val2);
7754 if (!SWIG_IsOK(ecode2)) {
7755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7756 }
7757 arg2 = static_cast< int >(val2);
7758 ecode3 = SWIG_AsVal_int(obj2, &val3);
7759 if (!SWIG_IsOK(ecode3)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7761 }
7762 arg3 = static_cast< int >(val3);
7763 {
7764 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 {
7768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769 }
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj = 0;
7778 wxRect *arg1 = (wxRect *) 0 ;
7779 wxPoint *arg2 = 0 ;
7780 bool result;
7781 void *argp1 = 0 ;
7782 int res1 = 0 ;
7783 wxPoint temp2 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 char * kwnames[] = {
7787 (char *) "self",(char *) "pt", NULL
7788 };
7789
7790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7794 }
7795 arg1 = reinterpret_cast< wxRect * >(argp1);
7796 {
7797 arg2 = &temp2;
7798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7799 }
7800 {
7801 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 {
7805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7806 }
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7814 PyObject *resultobj = 0;
7815 wxRect *arg1 = (wxRect *) 0 ;
7816 wxRect *arg2 = 0 ;
7817 bool result;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 wxRect temp2 ;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 char * kwnames[] = {
7824 (char *) "self",(char *) "rect", NULL
7825 };
7826
7827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7829 if (!SWIG_IsOK(res1)) {
7830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7831 }
7832 arg1 = reinterpret_cast< wxRect * >(argp1);
7833 {
7834 arg2 = &temp2;
7835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7836 }
7837 {
7838 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj = 0;
7852 wxRect *arg1 = (wxRect *) 0 ;
7853 wxRect *arg2 = 0 ;
7854 bool result;
7855 void *argp1 = 0 ;
7856 int res1 = 0 ;
7857 wxRect temp2 ;
7858 PyObject * obj0 = 0 ;
7859 PyObject * obj1 = 0 ;
7860 char * kwnames[] = {
7861 (char *) "self",(char *) "rect", NULL
7862 };
7863
7864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7866 if (!SWIG_IsOK(res1)) {
7867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7868 }
7869 arg1 = reinterpret_cast< wxRect * >(argp1);
7870 {
7871 arg2 = &temp2;
7872 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7873 }
7874 {
7875 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 {
7879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7880 }
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj = 0;
7889 wxRect *arg1 = (wxRect *) 0 ;
7890 wxRect *arg2 = 0 ;
7891 int arg3 = (int) wxBOTH ;
7892 wxRect result;
7893 void *argp1 = 0 ;
7894 int res1 = 0 ;
7895 wxRect temp2 ;
7896 int val3 ;
7897 int ecode3 = 0 ;
7898 PyObject * obj0 = 0 ;
7899 PyObject * obj1 = 0 ;
7900 PyObject * obj2 = 0 ;
7901 char * kwnames[] = {
7902 (char *) "self",(char *) "r",(char *) "dir", NULL
7903 };
7904
7905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7907 if (!SWIG_IsOK(res1)) {
7908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7909 }
7910 arg1 = reinterpret_cast< wxRect * >(argp1);
7911 {
7912 arg2 = &temp2;
7913 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7914 }
7915 if (obj2) {
7916 ecode3 = SWIG_AsVal_int(obj2, &val3);
7917 if (!SWIG_IsOK(ecode3)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7919 }
7920 arg3 = static_cast< int >(val3);
7921 }
7922 {
7923 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934 PyObject *resultobj = 0;
7935 wxRect *arg1 = (wxRect *) 0 ;
7936 int arg2 ;
7937 void *argp1 = 0 ;
7938 int res1 = 0 ;
7939 int val2 ;
7940 int ecode2 = 0 ;
7941 PyObject *swig_obj[2] ;
7942
7943 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7947 }
7948 arg1 = reinterpret_cast< wxRect * >(argp1);
7949 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7950 if (!SWIG_IsOK(ecode2)) {
7951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7952 }
7953 arg2 = static_cast< int >(val2);
7954 if (arg1) (arg1)->x = arg2;
7955
7956 resultobj = SWIG_Py_Void();
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *resultobj = 0;
7965 wxRect *arg1 = (wxRect *) 0 ;
7966 int result;
7967 void *argp1 = 0 ;
7968 int res1 = 0 ;
7969 PyObject *swig_obj[1] ;
7970
7971 if (!args) SWIG_fail;
7972 swig_obj[0] = args;
7973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7974 if (!SWIG_IsOK(res1)) {
7975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7976 }
7977 arg1 = reinterpret_cast< wxRect * >(argp1);
7978 result = (int) ((arg1)->x);
7979 resultobj = SWIG_From_int(static_cast< int >(result));
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7987 PyObject *resultobj = 0;
7988 wxRect *arg1 = (wxRect *) 0 ;
7989 int arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 int val2 ;
7993 int ecode2 = 0 ;
7994 PyObject *swig_obj[2] ;
7995
7996 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8000 }
8001 arg1 = reinterpret_cast< wxRect * >(argp1);
8002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8003 if (!SWIG_IsOK(ecode2)) {
8004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8005 }
8006 arg2 = static_cast< int >(val2);
8007 if (arg1) (arg1)->y = arg2;
8008
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *resultobj = 0;
8018 wxRect *arg1 = (wxRect *) 0 ;
8019 int result;
8020 void *argp1 = 0 ;
8021 int res1 = 0 ;
8022 PyObject *swig_obj[1] ;
8023
8024 if (!args) SWIG_fail;
8025 swig_obj[0] = args;
8026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8027 if (!SWIG_IsOK(res1)) {
8028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8029 }
8030 arg1 = reinterpret_cast< wxRect * >(argp1);
8031 result = (int) ((arg1)->y);
8032 resultobj = SWIG_From_int(static_cast< int >(result));
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041 wxRect *arg1 = (wxRect *) 0 ;
8042 int arg2 ;
8043 void *argp1 = 0 ;
8044 int res1 = 0 ;
8045 int val2 ;
8046 int ecode2 = 0 ;
8047 PyObject *swig_obj[2] ;
8048
8049 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8056 if (!SWIG_IsOK(ecode2)) {
8057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8058 }
8059 arg2 = static_cast< int >(val2);
8060 if (arg1) (arg1)->width = arg2;
8061
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 wxRect *arg1 = (wxRect *) 0 ;
8072 int result;
8073 void *argp1 = 0 ;
8074 int res1 = 0 ;
8075 PyObject *swig_obj[1] ;
8076
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8082 }
8083 arg1 = reinterpret_cast< wxRect * >(argp1);
8084 result = (int) ((arg1)->width);
8085 resultobj = SWIG_From_int(static_cast< int >(result));
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8093 PyObject *resultobj = 0;
8094 wxRect *arg1 = (wxRect *) 0 ;
8095 int arg2 ;
8096 void *argp1 = 0 ;
8097 int res1 = 0 ;
8098 int val2 ;
8099 int ecode2 = 0 ;
8100 PyObject *swig_obj[2] ;
8101
8102 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8106 }
8107 arg1 = reinterpret_cast< wxRect * >(argp1);
8108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 if (arg1) (arg1)->height = arg2;
8114
8115 resultobj = SWIG_Py_Void();
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8123 PyObject *resultobj = 0;
8124 wxRect *arg1 = (wxRect *) 0 ;
8125 int result;
8126 void *argp1 = 0 ;
8127 int res1 = 0 ;
8128 PyObject *swig_obj[1] ;
8129
8130 if (!args) SWIG_fail;
8131 swig_obj[0] = args;
8132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8133 if (!SWIG_IsOK(res1)) {
8134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8135 }
8136 arg1 = reinterpret_cast< wxRect * >(argp1);
8137 result = (int) ((arg1)->height);
8138 resultobj = SWIG_From_int(static_cast< int >(result));
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 int arg2 = (int) 0 ;
8149 int arg3 = (int) 0 ;
8150 int arg4 = (int) 0 ;
8151 int arg5 = (int) 0 ;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 int val2 ;
8155 int ecode2 = 0 ;
8156 int val3 ;
8157 int ecode3 = 0 ;
8158 int val4 ;
8159 int ecode4 = 0 ;
8160 int val5 ;
8161 int ecode5 = 0 ;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 PyObject * obj2 = 0 ;
8165 PyObject * obj3 = 0 ;
8166 PyObject * obj4 = 0 ;
8167 char * kwnames[] = {
8168 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8169 };
8170
8171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8173 if (!SWIG_IsOK(res1)) {
8174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8175 }
8176 arg1 = reinterpret_cast< wxRect * >(argp1);
8177 if (obj1) {
8178 ecode2 = SWIG_AsVal_int(obj1, &val2);
8179 if (!SWIG_IsOK(ecode2)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8181 }
8182 arg2 = static_cast< int >(val2);
8183 }
8184 if (obj2) {
8185 ecode3 = SWIG_AsVal_int(obj2, &val3);
8186 if (!SWIG_IsOK(ecode3)) {
8187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8188 }
8189 arg3 = static_cast< int >(val3);
8190 }
8191 if (obj3) {
8192 ecode4 = SWIG_AsVal_int(obj3, &val4);
8193 if (!SWIG_IsOK(ecode4)) {
8194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8195 }
8196 arg4 = static_cast< int >(val4);
8197 }
8198 if (obj4) {
8199 ecode5 = SWIG_AsVal_int(obj4, &val5);
8200 if (!SWIG_IsOK(ecode5)) {
8201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8202 }
8203 arg5 = static_cast< int >(val5);
8204 }
8205 {
8206 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 resultobj = SWIG_Py_Void();
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8217 PyObject *resultobj = 0;
8218 wxRect *arg1 = (wxRect *) 0 ;
8219 PyObject *result = 0 ;
8220 void *argp1 = 0 ;
8221 int res1 = 0 ;
8222 PyObject *swig_obj[1] ;
8223
8224 if (!args) SWIG_fail;
8225 swig_obj[0] = args;
8226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8229 }
8230 arg1 = reinterpret_cast< wxRect * >(argp1);
8231 {
8232 result = (PyObject *)wxRect_Get(arg1);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 resultobj = result;
8236 return resultobj;
8237 fail:
8238 return NULL;
8239 }
8240
8241
8242 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8243 PyObject *obj;
8244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8245 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8246 return SWIG_Py_Void();
8247 }
8248
8249 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8250 return SWIG_Python_InitShadowInstance(args);
8251 }
8252
8253 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8254 PyObject *resultobj = 0;
8255 wxRect *arg1 = (wxRect *) 0 ;
8256 wxRect *arg2 = (wxRect *) 0 ;
8257 PyObject *result = 0 ;
8258 void *argp1 = 0 ;
8259 int res1 = 0 ;
8260 void *argp2 = 0 ;
8261 int res2 = 0 ;
8262 PyObject * obj0 = 0 ;
8263 PyObject * obj1 = 0 ;
8264 char * kwnames[] = {
8265 (char *) "r1",(char *) "r2", NULL
8266 };
8267
8268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8270 if (!SWIG_IsOK(res1)) {
8271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8272 }
8273 arg1 = reinterpret_cast< wxRect * >(argp1);
8274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8275 if (!SWIG_IsOK(res2)) {
8276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8277 }
8278 arg2 = reinterpret_cast< wxRect * >(argp2);
8279 {
8280 if (!wxPyCheckForApp()) SWIG_fail;
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (PyObject *)wxIntersectRect(arg1,arg2);
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 resultobj = result;
8287 return resultobj;
8288 fail:
8289 return NULL;
8290 }
8291
8292
8293 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8294 PyObject *resultobj = 0;
8295 double arg1 = (double) 0.0 ;
8296 double arg2 = (double) 0.0 ;
8297 wxPoint2D *result = 0 ;
8298 double val1 ;
8299 int ecode1 = 0 ;
8300 double val2 ;
8301 int ecode2 = 0 ;
8302 PyObject * obj0 = 0 ;
8303 PyObject * obj1 = 0 ;
8304 char * kwnames[] = {
8305 (char *) "x",(char *) "y", NULL
8306 };
8307
8308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8309 if (obj0) {
8310 ecode1 = SWIG_AsVal_double(obj0, &val1);
8311 if (!SWIG_IsOK(ecode1)) {
8312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8313 }
8314 arg1 = static_cast< double >(val1);
8315 }
8316 if (obj1) {
8317 ecode2 = SWIG_AsVal_double(obj1, &val2);
8318 if (!SWIG_IsOK(ecode2)) {
8319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8320 }
8321 arg2 = static_cast< double >(val2);
8322 }
8323 {
8324 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8325 if (PyErr_Occurred()) SWIG_fail;
8326 }
8327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj = 0;
8336 wxPoint2D *arg1 = 0 ;
8337 wxPoint2D *result = 0 ;
8338 wxPoint2D temp1 ;
8339 PyObject * obj0 = 0 ;
8340 char * kwnames[] = {
8341 (char *) "pt", NULL
8342 };
8343
8344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8345 {
8346 arg1 = &temp1;
8347 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8348 }
8349 {
8350 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint *arg1 = 0 ;
8363 wxPoint2D *result = 0 ;
8364 wxPoint temp1 ;
8365 PyObject * obj0 = 0 ;
8366 char * kwnames[] = {
8367 (char *) "pt", NULL
8368 };
8369
8370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8371 {
8372 arg1 = &temp1;
8373 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8374 }
8375 {
8376 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8377 if (PyErr_Occurred()) SWIG_fail;
8378 }
8379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8380 return resultobj;
8381 fail:
8382 return NULL;
8383 }
8384
8385
8386 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8387 PyObject *resultobj = 0;
8388 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8389 void *argp1 = 0 ;
8390 int res1 = 0 ;
8391 PyObject *swig_obj[1] ;
8392
8393 if (!args) SWIG_fail;
8394 swig_obj[0] = args;
8395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8396 if (!SWIG_IsOK(res1)) {
8397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8398 }
8399 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8400 {
8401 delete arg1;
8402
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 resultobj = SWIG_Py_Void();
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8413 PyObject *resultobj = 0;
8414 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8415 int *arg2 = (int *) 0 ;
8416 int *arg3 = (int *) 0 ;
8417 void *argp1 = 0 ;
8418 int res1 = 0 ;
8419 int temp2 ;
8420 int res2 = SWIG_TMPOBJ ;
8421 int temp3 ;
8422 int res3 = SWIG_TMPOBJ ;
8423 PyObject *swig_obj[1] ;
8424
8425 arg2 = &temp2;
8426 arg3 = &temp3;
8427 if (!args) SWIG_fail;
8428 swig_obj[0] = args;
8429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8430 if (!SWIG_IsOK(res1)) {
8431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8432 }
8433 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8434 {
8435 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8436 if (PyErr_Occurred()) SWIG_fail;
8437 }
8438 resultobj = SWIG_Py_Void();
8439 if (SWIG_IsTmpObj(res2)) {
8440 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8441 } else {
8442 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8443 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8444 }
8445 if (SWIG_IsTmpObj(res3)) {
8446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8447 } else {
8448 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8450 }
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 int *arg2 = (int *) 0 ;
8461 int *arg3 = (int *) 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 int temp2 ;
8465 int res2 = SWIG_TMPOBJ ;
8466 int temp3 ;
8467 int res3 = SWIG_TMPOBJ ;
8468 PyObject *swig_obj[1] ;
8469
8470 arg2 = &temp2;
8471 arg3 = &temp3;
8472 if (!args) SWIG_fail;
8473 swig_obj[0] = args;
8474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8475 if (!SWIG_IsOK(res1)) {
8476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8477 }
8478 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8479 {
8480 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 resultobj = SWIG_Py_Void();
8484 if (SWIG_IsTmpObj(res2)) {
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8486 } else {
8487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8489 }
8490 if (SWIG_IsTmpObj(res3)) {
8491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8492 } else {
8493 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8505 double result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8515 }
8516 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8517 {
8518 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 resultobj = SWIG_From_double(static_cast< double >(result));
8522 return resultobj;
8523 fail:
8524 return NULL;
8525 }
8526
8527
8528 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8529 PyObject *resultobj = 0;
8530 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8531 double result;
8532 void *argp1 = 0 ;
8533 int res1 = 0 ;
8534 PyObject *swig_obj[1] ;
8535
8536 if (!args) SWIG_fail;
8537 swig_obj[0] = args;
8538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8539 if (!SWIG_IsOK(res1)) {
8540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8541 }
8542 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8543 {
8544 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 resultobj = SWIG_From_double(static_cast< double >(result));
8548 return resultobj;
8549 fail:
8550 return NULL;
8551 }
8552
8553
8554 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8555 PyObject *resultobj = 0;
8556 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8557 double arg2 ;
8558 void *argp1 = 0 ;
8559 int res1 = 0 ;
8560 double val2 ;
8561 int ecode2 = 0 ;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 char * kwnames[] = {
8565 (char *) "self",(char *) "length", NULL
8566 };
8567
8568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8570 if (!SWIG_IsOK(res1)) {
8571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8572 }
8573 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8574 ecode2 = SWIG_AsVal_double(obj1, &val2);
8575 if (!SWIG_IsOK(ecode2)) {
8576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8577 }
8578 arg2 = static_cast< double >(val2);
8579 {
8580 (arg1)->SetVectorLength(arg2);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_Py_Void();
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj = 0;
8592 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8593 double arg2 ;
8594 void *argp1 = 0 ;
8595 int res1 = 0 ;
8596 double val2 ;
8597 int ecode2 = 0 ;
8598 PyObject * obj0 = 0 ;
8599 PyObject * obj1 = 0 ;
8600 char * kwnames[] = {
8601 (char *) "self",(char *) "degrees", NULL
8602 };
8603
8604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8606 if (!SWIG_IsOK(res1)) {
8607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8608 }
8609 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8610 ecode2 = SWIG_AsVal_double(obj1, &val2);
8611 if (!SWIG_IsOK(ecode2)) {
8612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8613 }
8614 arg2 = static_cast< double >(val2);
8615 {
8616 (arg1)->SetVectorAngle(arg2);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 resultobj = SWIG_Py_Void();
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj = 0;
8628 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8629 wxPoint2D *arg2 = 0 ;
8630 double result;
8631 void *argp1 = 0 ;
8632 int res1 = 0 ;
8633 wxPoint2D temp2 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "pt", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8644 }
8645 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8646 {
8647 arg2 = &temp2;
8648 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8649 }
8650 {
8651 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 resultobj = SWIG_From_double(static_cast< double >(result));
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8662 PyObject *resultobj = 0;
8663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8664 wxPoint2D *arg2 = 0 ;
8665 double result;
8666 void *argp1 = 0 ;
8667 int res1 = 0 ;
8668 wxPoint2D temp2 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 char * kwnames[] = {
8672 (char *) "self",(char *) "pt", NULL
8673 };
8674
8675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8679 }
8680 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8681 {
8682 arg2 = &temp2;
8683 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8684 }
8685 {
8686 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 resultobj = SWIG_From_double(static_cast< double >(result));
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8697 PyObject *resultobj = 0;
8698 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8699 wxPoint2D *arg2 = 0 ;
8700 double result;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 wxPoint2D temp2 ;
8704 PyObject * obj0 = 0 ;
8705 PyObject * obj1 = 0 ;
8706 char * kwnames[] = {
8707 (char *) "self",(char *) "vec", NULL
8708 };
8709
8710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8712 if (!SWIG_IsOK(res1)) {
8713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8714 }
8715 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8716 {
8717 arg2 = &temp2;
8718 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8719 }
8720 {
8721 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8722 if (PyErr_Occurred()) SWIG_fail;
8723 }
8724 resultobj = SWIG_From_double(static_cast< double >(result));
8725 return resultobj;
8726 fail:
8727 return NULL;
8728 }
8729
8730
8731 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8732 PyObject *resultobj = 0;
8733 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8734 wxPoint2D *arg2 = 0 ;
8735 double result;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 wxPoint2D temp2 ;
8739 PyObject * obj0 = 0 ;
8740 PyObject * obj1 = 0 ;
8741 char * kwnames[] = {
8742 (char *) "self",(char *) "vec", NULL
8743 };
8744
8745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8747 if (!SWIG_IsOK(res1)) {
8748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8749 }
8750 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8751 {
8752 arg2 = &temp2;
8753 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8754 }
8755 {
8756 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 resultobj = SWIG_From_double(static_cast< double >(result));
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 wxPoint2D result;
8770 void *argp1 = 0 ;
8771 int res1 = 0 ;
8772 PyObject *swig_obj[1] ;
8773
8774 if (!args) SWIG_fail;
8775 swig_obj[0] = args;
8776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8777 if (!SWIG_IsOK(res1)) {
8778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8779 }
8780 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8781 {
8782 result = (arg1)->operator -();
8783 if (PyErr_Occurred()) SWIG_fail;
8784 }
8785 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8786 return resultobj;
8787 fail:
8788 return NULL;
8789 }
8790
8791
8792 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8793 PyObject *resultobj = 0;
8794 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8795 wxPoint2D *arg2 = 0 ;
8796 wxPoint2D *result = 0 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 wxPoint2D temp2 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "pt", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8810 }
8811 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8812 {
8813 arg2 = &temp2;
8814 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8815 }
8816 {
8817 {
8818 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8819 result = (wxPoint2D *) &_result_ref;
8820 }
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 wxPoint2D *arg2 = 0 ;
8834 wxPoint2D *result = 0 ;
8835 void *argp1 = 0 ;
8836 int res1 = 0 ;
8837 wxPoint2D temp2 ;
8838 PyObject * obj0 = 0 ;
8839 PyObject * obj1 = 0 ;
8840 char * kwnames[] = {
8841 (char *) "self",(char *) "pt", NULL
8842 };
8843
8844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8846 if (!SWIG_IsOK(res1)) {
8847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8848 }
8849 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8850 {
8851 arg2 = &temp2;
8852 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8853 }
8854 {
8855 {
8856 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8857 result = (wxPoint2D *) &_result_ref;
8858 }
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8869 PyObject *resultobj = 0;
8870 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8871 wxPoint2D *arg2 = 0 ;
8872 wxPoint2D *result = 0 ;
8873 void *argp1 = 0 ;
8874 int res1 = 0 ;
8875 wxPoint2D temp2 ;
8876 PyObject * obj0 = 0 ;
8877 PyObject * obj1 = 0 ;
8878 char * kwnames[] = {
8879 (char *) "self",(char *) "pt", NULL
8880 };
8881
8882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8884 if (!SWIG_IsOK(res1)) {
8885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8886 }
8887 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8888 {
8889 arg2 = &temp2;
8890 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8891 }
8892 {
8893 {
8894 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8895 result = (wxPoint2D *) &_result_ref;
8896 }
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 wxPoint2D *arg2 = 0 ;
8910 wxPoint2D *result = 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 wxPoint2D temp2 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "pt", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 {
8927 arg2 = &temp2;
8928 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8929 }
8930 {
8931 {
8932 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8933 result = (wxPoint2D *) &_result_ref;
8934 }
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8945 PyObject *resultobj = 0;
8946 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8947 PyObject *arg2 = (PyObject *) 0 ;
8948 bool result;
8949 void *argp1 = 0 ;
8950 int res1 = 0 ;
8951 PyObject * obj0 = 0 ;
8952 PyObject * obj1 = 0 ;
8953 char * kwnames[] = {
8954 (char *) "self",(char *) "other", NULL
8955 };
8956
8957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8959 if (!SWIG_IsOK(res1)) {
8960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8961 }
8962 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8963 arg2 = obj1;
8964 {
8965 result = (bool)wxPoint2D___eq__(arg1,arg2);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 {
8969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8970 }
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8978 PyObject *resultobj = 0;
8979 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8980 PyObject *arg2 = (PyObject *) 0 ;
8981 bool result;
8982 void *argp1 = 0 ;
8983 int res1 = 0 ;
8984 PyObject * obj0 = 0 ;
8985 PyObject * obj1 = 0 ;
8986 char * kwnames[] = {
8987 (char *) "self",(char *) "other", NULL
8988 };
8989
8990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8992 if (!SWIG_IsOK(res1)) {
8993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8994 }
8995 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8996 arg2 = obj1;
8997 {
8998 result = (bool)wxPoint2D___ne__(arg1,arg2);
8999 if (PyErr_Occurred()) SWIG_fail;
9000 }
9001 {
9002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9003 }
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011 PyObject *resultobj = 0;
9012 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9013 double arg2 ;
9014 void *argp1 = 0 ;
9015 int res1 = 0 ;
9016 double val2 ;
9017 int ecode2 = 0 ;
9018 PyObject *swig_obj[2] ;
9019
9020 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9022 if (!SWIG_IsOK(res1)) {
9023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9024 }
9025 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9026 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9027 if (!SWIG_IsOK(ecode2)) {
9028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9029 }
9030 arg2 = static_cast< double >(val2);
9031 if (arg1) (arg1)->m_x = arg2;
9032
9033 resultobj = SWIG_Py_Void();
9034 return resultobj;
9035 fail:
9036 return NULL;
9037 }
9038
9039
9040 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9041 PyObject *resultobj = 0;
9042 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9043 double result;
9044 void *argp1 = 0 ;
9045 int res1 = 0 ;
9046 PyObject *swig_obj[1] ;
9047
9048 if (!args) SWIG_fail;
9049 swig_obj[0] = args;
9050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9051 if (!SWIG_IsOK(res1)) {
9052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9053 }
9054 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9055 result = (double) ((arg1)->m_x);
9056 resultobj = SWIG_From_double(static_cast< double >(result));
9057 return resultobj;
9058 fail:
9059 return NULL;
9060 }
9061
9062
9063 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9064 PyObject *resultobj = 0;
9065 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9066 double arg2 ;
9067 void *argp1 = 0 ;
9068 int res1 = 0 ;
9069 double val2 ;
9070 int ecode2 = 0 ;
9071 PyObject *swig_obj[2] ;
9072
9073 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9077 }
9078 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9079 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9080 if (!SWIG_IsOK(ecode2)) {
9081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9082 }
9083 arg2 = static_cast< double >(val2);
9084 if (arg1) (arg1)->m_y = arg2;
9085
9086 resultobj = SWIG_Py_Void();
9087 return resultobj;
9088 fail:
9089 return NULL;
9090 }
9091
9092
9093 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9094 PyObject *resultobj = 0;
9095 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9096 double result;
9097 void *argp1 = 0 ;
9098 int res1 = 0 ;
9099 PyObject *swig_obj[1] ;
9100
9101 if (!args) SWIG_fail;
9102 swig_obj[0] = args;
9103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9104 if (!SWIG_IsOK(res1)) {
9105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9106 }
9107 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9108 result = (double) ((arg1)->m_y);
9109 resultobj = SWIG_From_double(static_cast< double >(result));
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9119 double arg2 = (double) 0 ;
9120 double arg3 = (double) 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 double val2 ;
9124 int ecode2 = 0 ;
9125 double val3 ;
9126 int ecode3 = 0 ;
9127 PyObject * obj0 = 0 ;
9128 PyObject * obj1 = 0 ;
9129 PyObject * obj2 = 0 ;
9130 char * kwnames[] = {
9131 (char *) "self",(char *) "x",(char *) "y", NULL
9132 };
9133
9134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9136 if (!SWIG_IsOK(res1)) {
9137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9138 }
9139 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9140 if (obj1) {
9141 ecode2 = SWIG_AsVal_double(obj1, &val2);
9142 if (!SWIG_IsOK(ecode2)) {
9143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9144 }
9145 arg2 = static_cast< double >(val2);
9146 }
9147 if (obj2) {
9148 ecode3 = SWIG_AsVal_double(obj2, &val3);
9149 if (!SWIG_IsOK(ecode3)) {
9150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9151 }
9152 arg3 = static_cast< double >(val3);
9153 }
9154 {
9155 wxPoint2D_Set(arg1,arg2,arg3);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 resultobj = SWIG_Py_Void();
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9166 PyObject *resultobj = 0;
9167 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9168 PyObject *result = 0 ;
9169 void *argp1 = 0 ;
9170 int res1 = 0 ;
9171 PyObject *swig_obj[1] ;
9172
9173 if (!args) SWIG_fail;
9174 swig_obj[0] = args;
9175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9176 if (!SWIG_IsOK(res1)) {
9177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9178 }
9179 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9180 {
9181 result = (PyObject *)wxPoint2D_Get(arg1);
9182 if (PyErr_Occurred()) SWIG_fail;
9183 }
9184 resultobj = result;
9185 return resultobj;
9186 fail:
9187 return NULL;
9188 }
9189
9190
9191 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9192 PyObject *obj;
9193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9194 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9195 return SWIG_Py_Void();
9196 }
9197
9198 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199 return SWIG_Python_InitShadowInstance(args);
9200 }
9201
9202 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9203 PyObject *resultobj = 0;
9204 wxDouble arg1 = (wxDouble) 0.0 ;
9205 wxDouble arg2 = (wxDouble) 0.0 ;
9206 wxDouble arg3 = (wxDouble) 0.0 ;
9207 wxDouble arg4 = (wxDouble) 0.0 ;
9208 wxRect2D *result = 0 ;
9209 void *argp1 ;
9210 int res1 = 0 ;
9211 void *argp2 ;
9212 int res2 = 0 ;
9213 void *argp3 ;
9214 int res3 = 0 ;
9215 void *argp4 ;
9216 int res4 = 0 ;
9217 PyObject * obj0 = 0 ;
9218 PyObject * obj1 = 0 ;
9219 PyObject * obj2 = 0 ;
9220 PyObject * obj3 = 0 ;
9221 char * kwnames[] = {
9222 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9223 };
9224
9225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9226 if (obj0) {
9227 {
9228 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9231 }
9232 if (!argp1) {
9233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9234 } else {
9235 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9236 arg1 = *temp;
9237 if (SWIG_IsNewObj(res1)) delete temp;
9238 }
9239 }
9240 }
9241 if (obj1) {
9242 {
9243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9244 if (!SWIG_IsOK(res2)) {
9245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9246 }
9247 if (!argp2) {
9248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9249 } else {
9250 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9251 arg2 = *temp;
9252 if (SWIG_IsNewObj(res2)) delete temp;
9253 }
9254 }
9255 }
9256 if (obj2) {
9257 {
9258 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9259 if (!SWIG_IsOK(res3)) {
9260 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9261 }
9262 if (!argp3) {
9263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9264 } else {
9265 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9266 arg3 = *temp;
9267 if (SWIG_IsNewObj(res3)) delete temp;
9268 }
9269 }
9270 }
9271 if (obj3) {
9272 {
9273 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9274 if (!SWIG_IsOK(res4)) {
9275 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9276 }
9277 if (!argp4) {
9278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9279 } else {
9280 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9281 arg4 = *temp;
9282 if (SWIG_IsNewObj(res4)) delete temp;
9283 }
9284 }
9285 }
9286 {
9287 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9288 if (PyErr_Occurred()) SWIG_fail;
9289 }
9290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9291 return resultobj;
9292 fail:
9293 return NULL;
9294 }
9295
9296
9297 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9298 PyObject *resultobj = 0;
9299 wxRect2D *arg1 = (wxRect2D *) 0 ;
9300 void *argp1 = 0 ;
9301 int res1 = 0 ;
9302 PyObject *swig_obj[1] ;
9303
9304 if (!args) SWIG_fail;
9305 swig_obj[0] = args;
9306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9309 }
9310 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9311 {
9312 delete arg1;
9313
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_Py_Void();
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9324 PyObject *resultobj = 0;
9325 wxRect2D *arg1 = (wxRect2D *) 0 ;
9326 wxPoint2D result;
9327 void *argp1 = 0 ;
9328 int res1 = 0 ;
9329 PyObject *swig_obj[1] ;
9330
9331 if (!args) SWIG_fail;
9332 swig_obj[0] = args;
9333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9334 if (!SWIG_IsOK(res1)) {
9335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9336 }
9337 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9338 {
9339 result = (arg1)->GetPosition();
9340 if (PyErr_Occurred()) SWIG_fail;
9341 }
9342 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9343 return resultobj;
9344 fail:
9345 return NULL;
9346 }
9347
9348
9349 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9350 PyObject *resultobj = 0;
9351 wxRect2D *arg1 = (wxRect2D *) 0 ;
9352 wxSize result;
9353 void *argp1 = 0 ;
9354 int res1 = 0 ;
9355 PyObject *swig_obj[1] ;
9356
9357 if (!args) SWIG_fail;
9358 swig_obj[0] = args;
9359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9360 if (!SWIG_IsOK(res1)) {
9361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9362 }
9363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9364 {
9365 result = (arg1)->GetSize();
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9376 PyObject *resultobj = 0;
9377 wxRect2D *arg1 = (wxRect2D *) 0 ;
9378 wxDouble result;
9379 void *argp1 = 0 ;
9380 int res1 = 0 ;
9381 PyObject *swig_obj[1] ;
9382
9383 if (!args) SWIG_fail;
9384 swig_obj[0] = args;
9385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9386 if (!SWIG_IsOK(res1)) {
9387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9388 }
9389 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9390 {
9391 result = ((wxRect2D const *)arg1)->GetLeft();
9392 if (PyErr_Occurred()) SWIG_fail;
9393 }
9394 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9402 PyObject *resultobj = 0;
9403 wxRect2D *arg1 = (wxRect2D *) 0 ;
9404 wxDouble arg2 ;
9405 void *argp1 = 0 ;
9406 int res1 = 0 ;
9407 void *argp2 ;
9408 int res2 = 0 ;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 char * kwnames[] = {
9412 (char *) "self",(char *) "n", NULL
9413 };
9414
9415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9417 if (!SWIG_IsOK(res1)) {
9418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9419 }
9420 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9421 {
9422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9423 if (!SWIG_IsOK(res2)) {
9424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9425 }
9426 if (!argp2) {
9427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9428 } else {
9429 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9430 arg2 = *temp;
9431 if (SWIG_IsNewObj(res2)) delete temp;
9432 }
9433 }
9434 {
9435 (arg1)->SetLeft(arg2);
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_Py_Void();
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxRect2D *arg1 = (wxRect2D *) 0 ;
9448 wxDouble arg2 ;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 void *argp2 ;
9452 int res2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "self",(char *) "n", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9463 }
9464 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9465 {
9466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9467 if (!SWIG_IsOK(res2)) {
9468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9469 }
9470 if (!argp2) {
9471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9472 } else {
9473 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9474 arg2 = *temp;
9475 if (SWIG_IsNewObj(res2)) delete temp;
9476 }
9477 }
9478 {
9479 (arg1)->MoveLeftTo(arg2);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 PyObject *resultobj = 0;
9491 wxRect2D *arg1 = (wxRect2D *) 0 ;
9492 wxDouble result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 PyObject *swig_obj[1] ;
9496
9497 if (!args) SWIG_fail;
9498 swig_obj[0] = args;
9499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9502 }
9503 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9504 {
9505 result = ((wxRect2D const *)arg1)->GetTop();
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj = 0;
9517 wxRect2D *arg1 = (wxRect2D *) 0 ;
9518 wxDouble arg2 ;
9519 void *argp1 = 0 ;
9520 int res1 = 0 ;
9521 void *argp2 ;
9522 int res2 = 0 ;
9523 PyObject * obj0 = 0 ;
9524 PyObject * obj1 = 0 ;
9525 char * kwnames[] = {
9526 (char *) "self",(char *) "n", NULL
9527 };
9528
9529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9533 }
9534 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9535 {
9536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9537 if (!SWIG_IsOK(res2)) {
9538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9539 }
9540 if (!argp2) {
9541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9542 } else {
9543 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9544 arg2 = *temp;
9545 if (SWIG_IsNewObj(res2)) delete temp;
9546 }
9547 }
9548 {
9549 (arg1)->SetTop(arg2);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_Py_Void();
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj = 0;
9561 wxRect2D *arg1 = (wxRect2D *) 0 ;
9562 wxDouble arg2 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 void *argp2 ;
9566 int res2 = 0 ;
9567 PyObject * obj0 = 0 ;
9568 PyObject * obj1 = 0 ;
9569 char * kwnames[] = {
9570 (char *) "self",(char *) "n", NULL
9571 };
9572
9573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9575 if (!SWIG_IsOK(res1)) {
9576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9577 }
9578 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9579 {
9580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9581 if (!SWIG_IsOK(res2)) {
9582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9583 }
9584 if (!argp2) {
9585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9586 } else {
9587 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9588 arg2 = *temp;
9589 if (SWIG_IsNewObj(res2)) delete temp;
9590 }
9591 }
9592 {
9593 (arg1)->MoveTopTo(arg2);
9594 if (PyErr_Occurred()) SWIG_fail;
9595 }
9596 resultobj = SWIG_Py_Void();
9597 return resultobj;
9598 fail:
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9604 PyObject *resultobj = 0;
9605 wxRect2D *arg1 = (wxRect2D *) 0 ;
9606 wxDouble result;
9607 void *argp1 = 0 ;
9608 int res1 = 0 ;
9609 PyObject *swig_obj[1] ;
9610
9611 if (!args) SWIG_fail;
9612 swig_obj[0] = args;
9613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9614 if (!SWIG_IsOK(res1)) {
9615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9616 }
9617 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9618 {
9619 result = ((wxRect2D const *)arg1)->GetBottom();
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj = 0;
9631 wxRect2D *arg1 = (wxRect2D *) 0 ;
9632 wxDouble arg2 ;
9633 void *argp1 = 0 ;
9634 int res1 = 0 ;
9635 void *argp2 ;
9636 int res2 = 0 ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char * kwnames[] = {
9640 (char *) "self",(char *) "n", NULL
9641 };
9642
9643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9645 if (!SWIG_IsOK(res1)) {
9646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9647 }
9648 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9649 {
9650 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9651 if (!SWIG_IsOK(res2)) {
9652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9653 }
9654 if (!argp2) {
9655 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9656 } else {
9657 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9658 arg2 = *temp;
9659 if (SWIG_IsNewObj(res2)) delete temp;
9660 }
9661 }
9662 {
9663 (arg1)->SetBottom(arg2);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_Py_Void();
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxRect2D *arg1 = (wxRect2D *) 0 ;
9676 wxDouble arg2 ;
9677 void *argp1 = 0 ;
9678 int res1 = 0 ;
9679 void *argp2 ;
9680 int res2 = 0 ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 char * kwnames[] = {
9684 (char *) "self",(char *) "n", NULL
9685 };
9686
9687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9689 if (!SWIG_IsOK(res1)) {
9690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9691 }
9692 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9693 {
9694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9695 if (!SWIG_IsOK(res2)) {
9696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9697 }
9698 if (!argp2) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9700 } else {
9701 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9702 arg2 = *temp;
9703 if (SWIG_IsNewObj(res2)) delete temp;
9704 }
9705 }
9706 {
9707 (arg1)->MoveBottomTo(arg2);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = SWIG_Py_Void();
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9718 PyObject *resultobj = 0;
9719 wxRect2D *arg1 = (wxRect2D *) 0 ;
9720 wxDouble result;
9721 void *argp1 = 0 ;
9722 int res1 = 0 ;
9723 PyObject *swig_obj[1] ;
9724
9725 if (!args) SWIG_fail;
9726 swig_obj[0] = args;
9727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9728 if (!SWIG_IsOK(res1)) {
9729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9730 }
9731 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9732 {
9733 result = ((wxRect2D const *)arg1)->GetRight();
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9737 return resultobj;
9738 fail:
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9744 PyObject *resultobj = 0;
9745 wxRect2D *arg1 = (wxRect2D *) 0 ;
9746 wxDouble arg2 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 void *argp2 ;
9750 int res2 = 0 ;
9751 PyObject * obj0 = 0 ;
9752 PyObject * obj1 = 0 ;
9753 char * kwnames[] = {
9754 (char *) "self",(char *) "n", NULL
9755 };
9756
9757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9759 if (!SWIG_IsOK(res1)) {
9760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9761 }
9762 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9763 {
9764 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9765 if (!SWIG_IsOK(res2)) {
9766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9767 }
9768 if (!argp2) {
9769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9770 } else {
9771 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9772 arg2 = *temp;
9773 if (SWIG_IsNewObj(res2)) delete temp;
9774 }
9775 }
9776 {
9777 (arg1)->SetRight(arg2);
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 resultobj = SWIG_Py_Void();
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9788 PyObject *resultobj = 0;
9789 wxRect2D *arg1 = (wxRect2D *) 0 ;
9790 wxDouble arg2 ;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 void *argp2 ;
9794 int res2 = 0 ;
9795 PyObject * obj0 = 0 ;
9796 PyObject * obj1 = 0 ;
9797 char * kwnames[] = {
9798 (char *) "self",(char *) "n", NULL
9799 };
9800
9801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9805 }
9806 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9807 {
9808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9809 if (!SWIG_IsOK(res2)) {
9810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9811 }
9812 if (!argp2) {
9813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9814 } else {
9815 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9816 arg2 = *temp;
9817 if (SWIG_IsNewObj(res2)) delete temp;
9818 }
9819 }
9820 {
9821 (arg1)->MoveRightTo(arg2);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_Py_Void();
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxRect2D *arg1 = (wxRect2D *) 0 ;
9834 wxPoint2D result;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9844 }
9845 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9846 {
9847 result = ((wxRect2D const *)arg1)->GetLeftTop();
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9851 return resultobj;
9852 fail:
9853 return NULL;
9854 }
9855
9856
9857 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9858 PyObject *resultobj = 0;
9859 wxRect2D *arg1 = (wxRect2D *) 0 ;
9860 wxPoint2D *arg2 = 0 ;
9861 void *argp1 = 0 ;
9862 int res1 = 0 ;
9863 wxPoint2D temp2 ;
9864 PyObject * obj0 = 0 ;
9865 PyObject * obj1 = 0 ;
9866 char * kwnames[] = {
9867 (char *) "self",(char *) "pt", NULL
9868 };
9869
9870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9872 if (!SWIG_IsOK(res1)) {
9873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9874 }
9875 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9876 {
9877 arg2 = &temp2;
9878 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9879 }
9880 {
9881 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 resultobj = SWIG_Py_Void();
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj = 0;
9893 wxRect2D *arg1 = (wxRect2D *) 0 ;
9894 wxPoint2D *arg2 = 0 ;
9895 void *argp1 = 0 ;
9896 int res1 = 0 ;
9897 wxPoint2D temp2 ;
9898 PyObject * obj0 = 0 ;
9899 PyObject * obj1 = 0 ;
9900 char * kwnames[] = {
9901 (char *) "self",(char *) "pt", NULL
9902 };
9903
9904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9906 if (!SWIG_IsOK(res1)) {
9907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9908 }
9909 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9910 {
9911 arg2 = &temp2;
9912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9913 }
9914 {
9915 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_Py_Void();
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 PyObject *resultobj = 0;
9927 wxRect2D *arg1 = (wxRect2D *) 0 ;
9928 wxPoint2D result;
9929 void *argp1 = 0 ;
9930 int res1 = 0 ;
9931 PyObject *swig_obj[1] ;
9932
9933 if (!args) SWIG_fail;
9934 swig_obj[0] = args;
9935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9936 if (!SWIG_IsOK(res1)) {
9937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9938 }
9939 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9940 {
9941 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj = 0;
9953 wxRect2D *arg1 = (wxRect2D *) 0 ;
9954 wxPoint2D *arg2 = 0 ;
9955 void *argp1 = 0 ;
9956 int res1 = 0 ;
9957 wxPoint2D temp2 ;
9958 PyObject * obj0 = 0 ;
9959 PyObject * obj1 = 0 ;
9960 char * kwnames[] = {
9961 (char *) "self",(char *) "pt", NULL
9962 };
9963
9964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9968 }
9969 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9970 {
9971 arg2 = &temp2;
9972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9973 }
9974 {
9975 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_Py_Void();
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj = 0;
9987 wxRect2D *arg1 = (wxRect2D *) 0 ;
9988 wxPoint2D *arg2 = 0 ;
9989 void *argp1 = 0 ;
9990 int res1 = 0 ;
9991 wxPoint2D temp2 ;
9992 PyObject * obj0 = 0 ;
9993 PyObject * obj1 = 0 ;
9994 char * kwnames[] = {
9995 (char *) "self",(char *) "pt", NULL
9996 };
9997
9998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10000 if (!SWIG_IsOK(res1)) {
10001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10002 }
10003 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10004 {
10005 arg2 = &temp2;
10006 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10007 }
10008 {
10009 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 resultobj = SWIG_Py_Void();
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 PyObject *resultobj = 0;
10021 wxRect2D *arg1 = (wxRect2D *) 0 ;
10022 wxPoint2D result;
10023 void *argp1 = 0 ;
10024 int res1 = 0 ;
10025 PyObject *swig_obj[1] ;
10026
10027 if (!args) SWIG_fail;
10028 swig_obj[0] = args;
10029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10032 }
10033 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10034 {
10035 result = ((wxRect2D const *)arg1)->GetRightTop();
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10039 return resultobj;
10040 fail:
10041 return NULL;
10042 }
10043
10044
10045 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj = 0;
10047 wxRect2D *arg1 = (wxRect2D *) 0 ;
10048 wxPoint2D *arg2 = 0 ;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 wxPoint2D temp2 ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "pt", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10062 }
10063 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10064 {
10065 arg2 = &temp2;
10066 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10067 }
10068 {
10069 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 resultobj = SWIG_Py_Void();
10073 return resultobj;
10074 fail:
10075 return NULL;
10076 }
10077
10078
10079 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj = 0;
10081 wxRect2D *arg1 = (wxRect2D *) 0 ;
10082 wxPoint2D *arg2 = 0 ;
10083 void *argp1 = 0 ;
10084 int res1 = 0 ;
10085 wxPoint2D temp2 ;
10086 PyObject * obj0 = 0 ;
10087 PyObject * obj1 = 0 ;
10088 char * kwnames[] = {
10089 (char *) "self",(char *) "pt", NULL
10090 };
10091
10092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10094 if (!SWIG_IsOK(res1)) {
10095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10096 }
10097 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10098 {
10099 arg2 = &temp2;
10100 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10101 }
10102 {
10103 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 resultobj = SWIG_Py_Void();
10107 return resultobj;
10108 fail:
10109 return NULL;
10110 }
10111
10112
10113 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10114 PyObject *resultobj = 0;
10115 wxRect2D *arg1 = (wxRect2D *) 0 ;
10116 wxPoint2D result;
10117 void *argp1 = 0 ;
10118 int res1 = 0 ;
10119 PyObject *swig_obj[1] ;
10120
10121 if (!args) SWIG_fail;
10122 swig_obj[0] = args;
10123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10124 if (!SWIG_IsOK(res1)) {
10125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10126 }
10127 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10128 {
10129 result = ((wxRect2D const *)arg1)->GetRightBottom();
10130 if (PyErr_Occurred()) SWIG_fail;
10131 }
10132 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10133 return resultobj;
10134 fail:
10135 return NULL;
10136 }
10137
10138
10139 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10140 PyObject *resultobj = 0;
10141 wxRect2D *arg1 = (wxRect2D *) 0 ;
10142 wxPoint2D *arg2 = 0 ;
10143 void *argp1 = 0 ;
10144 int res1 = 0 ;
10145 wxPoint2D temp2 ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 char * kwnames[] = {
10149 (char *) "self",(char *) "pt", NULL
10150 };
10151
10152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10154 if (!SWIG_IsOK(res1)) {
10155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10156 }
10157 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10158 {
10159 arg2 = &temp2;
10160 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10161 }
10162 {
10163 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 resultobj = SWIG_Py_Void();
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj = 0;
10175 wxRect2D *arg1 = (wxRect2D *) 0 ;
10176 wxPoint2D *arg2 = 0 ;
10177 void *argp1 = 0 ;
10178 int res1 = 0 ;
10179 wxPoint2D temp2 ;
10180 PyObject * obj0 = 0 ;
10181 PyObject * obj1 = 0 ;
10182 char * kwnames[] = {
10183 (char *) "self",(char *) "pt", NULL
10184 };
10185
10186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10188 if (!SWIG_IsOK(res1)) {
10189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10190 }
10191 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10192 {
10193 arg2 = &temp2;
10194 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10195 }
10196 {
10197 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10198 if (PyErr_Occurred()) SWIG_fail;
10199 }
10200 resultobj = SWIG_Py_Void();
10201 return resultobj;
10202 fail:
10203 return NULL;
10204 }
10205
10206
10207 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10208 PyObject *resultobj = 0;
10209 wxRect2D *arg1 = (wxRect2D *) 0 ;
10210 wxPoint2D result;
10211 void *argp1 = 0 ;
10212 int res1 = 0 ;
10213 PyObject *swig_obj[1] ;
10214
10215 if (!args) SWIG_fail;
10216 swig_obj[0] = args;
10217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10218 if (!SWIG_IsOK(res1)) {
10219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10220 }
10221 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10222 {
10223 result = ((wxRect2D const *)arg1)->GetCentre();
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10227 return resultobj;
10228 fail:
10229 return NULL;
10230 }
10231
10232
10233 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10234 PyObject *resultobj = 0;
10235 wxRect2D *arg1 = (wxRect2D *) 0 ;
10236 wxPoint2D *arg2 = 0 ;
10237 void *argp1 = 0 ;
10238 int res1 = 0 ;
10239 wxPoint2D temp2 ;
10240 PyObject * obj0 = 0 ;
10241 PyObject * obj1 = 0 ;
10242 char * kwnames[] = {
10243 (char *) "self",(char *) "pt", NULL
10244 };
10245
10246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10248 if (!SWIG_IsOK(res1)) {
10249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10250 }
10251 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10252 {
10253 arg2 = &temp2;
10254 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10255 }
10256 {
10257 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 resultobj = SWIG_Py_Void();
10261 return resultobj;
10262 fail:
10263 return NULL;
10264 }
10265
10266
10267 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10268 PyObject *resultobj = 0;
10269 wxRect2D *arg1 = (wxRect2D *) 0 ;
10270 wxPoint2D *arg2 = 0 ;
10271 void *argp1 = 0 ;
10272 int res1 = 0 ;
10273 wxPoint2D temp2 ;
10274 PyObject * obj0 = 0 ;
10275 PyObject * obj1 = 0 ;
10276 char * kwnames[] = {
10277 (char *) "self",(char *) "pt", NULL
10278 };
10279
10280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10282 if (!SWIG_IsOK(res1)) {
10283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10284 }
10285 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10286 {
10287 arg2 = &temp2;
10288 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10289 }
10290 {
10291 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 resultobj = SWIG_Py_Void();
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxRect2D *arg1 = (wxRect2D *) 0 ;
10304 wxPoint2D *arg2 = 0 ;
10305 wxOutCode result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 wxPoint2D temp2 ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "pt", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10319 }
10320 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10321 {
10322 arg2 = &temp2;
10323 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10324 }
10325 {
10326 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10327 if (PyErr_Occurred()) SWIG_fail;
10328 }
10329 resultobj = SWIG_From_int(static_cast< int >(result));
10330 return resultobj;
10331 fail:
10332 return NULL;
10333 }
10334
10335
10336 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10337 PyObject *resultobj = 0;
10338 wxRect2D *arg1 = (wxRect2D *) 0 ;
10339 wxPoint2D *arg2 = 0 ;
10340 bool result;
10341 void *argp1 = 0 ;
10342 int res1 = 0 ;
10343 wxPoint2D temp2 ;
10344 PyObject * obj0 = 0 ;
10345 PyObject * obj1 = 0 ;
10346 char * kwnames[] = {
10347 (char *) "self",(char *) "pt", NULL
10348 };
10349
10350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10352 if (!SWIG_IsOK(res1)) {
10353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10354 }
10355 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10356 {
10357 arg2 = &temp2;
10358 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10359 }
10360 {
10361 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 {
10365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10366 }
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj = 0;
10375 wxRect2D *arg1 = (wxRect2D *) 0 ;
10376 wxRect2D *arg2 = 0 ;
10377 bool result;
10378 void *argp1 = 0 ;
10379 int res1 = 0 ;
10380 wxRect2D temp2 ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 char * kwnames[] = {
10384 (char *) "self",(char *) "rect", NULL
10385 };
10386
10387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10389 if (!SWIG_IsOK(res1)) {
10390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10391 }
10392 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10393 {
10394 arg2 = &temp2;
10395 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10396 }
10397 {
10398 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 {
10402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10403 }
10404 return resultobj;
10405 fail:
10406 return NULL;
10407 }
10408
10409
10410 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10411 PyObject *resultobj = 0;
10412 wxRect2D *arg1 = (wxRect2D *) 0 ;
10413 bool result;
10414 void *argp1 = 0 ;
10415 int res1 = 0 ;
10416 PyObject *swig_obj[1] ;
10417
10418 if (!args) SWIG_fail;
10419 swig_obj[0] = args;
10420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10423 }
10424 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10425 {
10426 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 {
10430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10431 }
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10439 PyObject *resultobj = 0;
10440 wxRect2D *arg1 = (wxRect2D *) 0 ;
10441 wxRect2D *arg2 = 0 ;
10442 bool result;
10443 void *argp1 = 0 ;
10444 int res1 = 0 ;
10445 wxRect2D temp2 ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 char * kwnames[] = {
10449 (char *) "self",(char *) "rect", NULL
10450 };
10451
10452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10454 if (!SWIG_IsOK(res1)) {
10455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10456 }
10457 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10458 {
10459 arg2 = &temp2;
10460 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10461 }
10462 {
10463 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 {
10467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10468 }
10469 return resultobj;
10470 fail:
10471 return NULL;
10472 }
10473
10474
10475 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10476 PyObject *resultobj = 0;
10477 wxRect2D *arg1 = (wxRect2D *) 0 ;
10478 wxDouble arg2 ;
10479 wxDouble arg3 ;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 void *argp2 ;
10483 int res2 = 0 ;
10484 void *argp3 ;
10485 int res3 = 0 ;
10486
10487 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10489 if (!SWIG_IsOK(res1)) {
10490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10491 }
10492 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10493 {
10494 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10495 if (!SWIG_IsOK(res2)) {
10496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10497 }
10498 if (!argp2) {
10499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10500 } else {
10501 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10502 arg2 = *temp;
10503 if (SWIG_IsNewObj(res2)) delete temp;
10504 }
10505 }
10506 {
10507 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10508 if (!SWIG_IsOK(res3)) {
10509 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10510 }
10511 if (!argp3) {
10512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10513 } else {
10514 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10515 arg3 = *temp;
10516 if (SWIG_IsNewObj(res3)) delete temp;
10517 }
10518 }
10519 {
10520 (arg1)->Inset(arg2,arg3);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 resultobj = SWIG_Py_Void();
10524 return resultobj;
10525 fail:
10526 return NULL;
10527 }
10528
10529
10530 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10531 PyObject *resultobj = 0;
10532 wxRect2D *arg1 = (wxRect2D *) 0 ;
10533 wxDouble arg2 ;
10534 wxDouble arg3 ;
10535 wxDouble arg4 ;
10536 wxDouble arg5 ;
10537 void *argp1 = 0 ;
10538 int res1 = 0 ;
10539 void *argp2 ;
10540 int res2 = 0 ;
10541 void *argp3 ;
10542 int res3 = 0 ;
10543 void *argp4 ;
10544 int res4 = 0 ;
10545 void *argp5 ;
10546 int res5 = 0 ;
10547
10548 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10552 }
10553 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10554 {
10555 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10556 if (!SWIG_IsOK(res2)) {
10557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10558 }
10559 if (!argp2) {
10560 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10561 } else {
10562 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10563 arg2 = *temp;
10564 if (SWIG_IsNewObj(res2)) delete temp;
10565 }
10566 }
10567 {
10568 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10569 if (!SWIG_IsOK(res3)) {
10570 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10571 }
10572 if (!argp3) {
10573 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10574 } else {
10575 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10576 arg3 = *temp;
10577 if (SWIG_IsNewObj(res3)) delete temp;
10578 }
10579 }
10580 {
10581 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10582 if (!SWIG_IsOK(res4)) {
10583 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10584 }
10585 if (!argp4) {
10586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10587 } else {
10588 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10589 arg4 = *temp;
10590 if (SWIG_IsNewObj(res4)) delete temp;
10591 }
10592 }
10593 {
10594 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10595 if (!SWIG_IsOK(res5)) {
10596 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10597 }
10598 if (!argp5) {
10599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10600 } else {
10601 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10602 arg5 = *temp;
10603 if (SWIG_IsNewObj(res5)) delete temp;
10604 }
10605 }
10606 {
10607 (arg1)->Inset(arg2,arg3,arg4,arg5);
10608 if (PyErr_Occurred()) SWIG_fail;
10609 }
10610 resultobj = SWIG_Py_Void();
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10618 int argc;
10619 PyObject *argv[6];
10620
10621 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10622 --argc;
10623 if (argc == 3) {
10624 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10625 }
10626 if (argc == 5) {
10627 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10628 }
10629
10630 fail:
10631 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10632 return NULL;
10633 }
10634
10635
10636 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10637 PyObject *resultobj = 0;
10638 wxRect2D *arg1 = (wxRect2D *) 0 ;
10639 wxPoint2D *arg2 = 0 ;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 wxPoint2D temp2 ;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 char * kwnames[] = {
10646 (char *) "self",(char *) "pt", NULL
10647 };
10648
10649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10653 }
10654 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10655 {
10656 arg2 = &temp2;
10657 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10658 }
10659 {
10660 (arg1)->Offset((wxPoint2D const &)*arg2);
10661 if (PyErr_Occurred()) SWIG_fail;
10662 }
10663 resultobj = SWIG_Py_Void();
10664 return resultobj;
10665 fail:
10666 return NULL;
10667 }
10668
10669
10670 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10671 PyObject *resultobj = 0;
10672 wxRect2D *arg1 = (wxRect2D *) 0 ;
10673 wxRect2D *arg2 = 0 ;
10674 void *argp1 = 0 ;
10675 int res1 = 0 ;
10676 wxRect2D temp2 ;
10677 PyObject * obj0 = 0 ;
10678 PyObject * obj1 = 0 ;
10679 char * kwnames[] = {
10680 (char *) "self",(char *) "rect", NULL
10681 };
10682
10683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10685 if (!SWIG_IsOK(res1)) {
10686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10687 }
10688 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10689 {
10690 arg2 = &temp2;
10691 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10692 }
10693 {
10694 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10695 if (PyErr_Occurred()) SWIG_fail;
10696 }
10697 resultobj = SWIG_Py_Void();
10698 return resultobj;
10699 fail:
10700 return NULL;
10701 }
10702
10703
10704 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10705 PyObject *resultobj = 0;
10706 wxRect2D *arg1 = (wxRect2D *) 0 ;
10707 int arg2 ;
10708 int arg3 ;
10709 wxPoint2D result;
10710 void *argp1 = 0 ;
10711 int res1 = 0 ;
10712 int val2 ;
10713 int ecode2 = 0 ;
10714 int val3 ;
10715 int ecode3 = 0 ;
10716 PyObject * obj0 = 0 ;
10717 PyObject * obj1 = 0 ;
10718 PyObject * obj2 = 0 ;
10719 char * kwnames[] = {
10720 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10721 };
10722
10723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10725 if (!SWIG_IsOK(res1)) {
10726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10727 }
10728 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10729 ecode2 = SWIG_AsVal_int(obj1, &val2);
10730 if (!SWIG_IsOK(ecode2)) {
10731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10732 }
10733 arg2 = static_cast< int >(val2);
10734 ecode3 = SWIG_AsVal_int(obj2, &val3);
10735 if (!SWIG_IsOK(ecode3)) {
10736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10737 }
10738 arg3 = static_cast< int >(val3);
10739 {
10740 result = (arg1)->Interpolate(arg2,arg3);
10741 if (PyErr_Occurred()) SWIG_fail;
10742 }
10743 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10744 return resultobj;
10745 fail:
10746 return NULL;
10747 }
10748
10749
10750 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10751 PyObject *resultobj = 0;
10752 wxRect2D *arg1 = (wxRect2D *) 0 ;
10753 wxRect2D *arg2 = 0 ;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 wxRect2D temp2 ;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 char * kwnames[] = {
10760 (char *) "self",(char *) "otherRect", NULL
10761 };
10762
10763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10767 }
10768 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10769 {
10770 arg2 = &temp2;
10771 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10772 }
10773 {
10774 (arg1)->Intersect((wxRect2D const &)*arg2);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 resultobj = SWIG_Py_Void();
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj = 0;
10786 wxRect2D *arg1 = (wxRect2D *) 0 ;
10787 wxRect2D *arg2 = 0 ;
10788 wxRect2D result;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 wxRect2D temp2 ;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "self",(char *) "otherRect", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10802 }
10803 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10804 {
10805 arg2 = &temp2;
10806 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10807 }
10808 {
10809 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxRect2D *arg1 = (wxRect2D *) 0 ;
10822 wxRect2D *arg2 = 0 ;
10823 bool result;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 wxRect2D temp2 ;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "self",(char *) "rect", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10835 if (!SWIG_IsOK(res1)) {
10836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10837 }
10838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10839 {
10840 arg2 = &temp2;
10841 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10842 }
10843 {
10844 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 {
10848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10849 }
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj = 0;
10858 wxRect2D *arg1 = (wxRect2D *) 0 ;
10859 wxRect2D *arg2 = 0 ;
10860 void *argp1 = 0 ;
10861 int res1 = 0 ;
10862 wxRect2D temp2 ;
10863 PyObject * obj0 = 0 ;
10864 PyObject * obj1 = 0 ;
10865 char * kwnames[] = {
10866 (char *) "self",(char *) "otherRect", NULL
10867 };
10868
10869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10871 if (!SWIG_IsOK(res1)) {
10872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10873 }
10874 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10875 {
10876 arg2 = &temp2;
10877 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10878 }
10879 {
10880 (arg1)->Union((wxRect2D const &)*arg2);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxRect2D *arg1 = (wxRect2D *) 0 ;
10893 wxRect2D *arg2 = 0 ;
10894 wxRect2D result;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 wxRect2D temp2 ;
10898 PyObject * obj0 = 0 ;
10899 PyObject * obj1 = 0 ;
10900 char * kwnames[] = {
10901 (char *) "self",(char *) "otherRect", NULL
10902 };
10903
10904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10906 if (!SWIG_IsOK(res1)) {
10907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10908 }
10909 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10910 {
10911 arg2 = &temp2;
10912 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10913 }
10914 {
10915 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10916 if (PyErr_Occurred()) SWIG_fail;
10917 }
10918 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10919 return resultobj;
10920 fail:
10921 return NULL;
10922 }
10923
10924
10925 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10926 PyObject *resultobj = 0;
10927 wxRect2D *arg1 = (wxRect2D *) 0 ;
10928 wxDouble arg2 ;
10929 void *argp1 = 0 ;
10930 int res1 = 0 ;
10931 void *argp2 ;
10932 int res2 = 0 ;
10933
10934 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10936 if (!SWIG_IsOK(res1)) {
10937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10938 }
10939 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10940 {
10941 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10942 if (!SWIG_IsOK(res2)) {
10943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10944 }
10945 if (!argp2) {
10946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10947 } else {
10948 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10949 arg2 = *temp;
10950 if (SWIG_IsNewObj(res2)) delete temp;
10951 }
10952 }
10953 {
10954 (arg1)->Scale(arg2);
10955 if (PyErr_Occurred()) SWIG_fail;
10956 }
10957 resultobj = SWIG_Py_Void();
10958 return resultobj;
10959 fail:
10960 return NULL;
10961 }
10962
10963
10964 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10965 PyObject *resultobj = 0;
10966 wxRect2D *arg1 = (wxRect2D *) 0 ;
10967 int arg2 ;
10968 int arg3 ;
10969 void *argp1 = 0 ;
10970 int res1 = 0 ;
10971 int val2 ;
10972 int ecode2 = 0 ;
10973 int val3 ;
10974 int ecode3 = 0 ;
10975
10976 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10980 }
10981 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10982 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10983 if (!SWIG_IsOK(ecode2)) {
10984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10985 }
10986 arg2 = static_cast< int >(val2);
10987 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10988 if (!SWIG_IsOK(ecode3)) {
10989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10990 }
10991 arg3 = static_cast< int >(val3);
10992 {
10993 (arg1)->Scale(arg2,arg3);
10994 if (PyErr_Occurred()) SWIG_fail;
10995 }
10996 resultobj = SWIG_Py_Void();
10997 return resultobj;
10998 fail:
10999 return NULL;
11000 }
11001
11002
11003 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11004 int argc;
11005 PyObject *argv[4];
11006
11007 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11008 --argc;
11009 if (argc == 2) {
11010 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11011 }
11012 if (argc == 3) {
11013 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11014 }
11015
11016 fail:
11017 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11018 return NULL;
11019 }
11020
11021
11022 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj = 0;
11024 wxRect2D *arg1 = (wxRect2D *) 0 ;
11025 PyObject *arg2 = (PyObject *) 0 ;
11026 bool result;
11027 void *argp1 = 0 ;
11028 int res1 = 0 ;
11029 PyObject * obj0 = 0 ;
11030 PyObject * obj1 = 0 ;
11031 char * kwnames[] = {
11032 (char *) "self",(char *) "other", NULL
11033 };
11034
11035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11037 if (!SWIG_IsOK(res1)) {
11038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11039 }
11040 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11041 arg2 = obj1;
11042 {
11043 result = (bool)wxRect2D___eq__(arg1,arg2);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 {
11047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11048 }
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11056 PyObject *resultobj = 0;
11057 wxRect2D *arg1 = (wxRect2D *) 0 ;
11058 PyObject *arg2 = (PyObject *) 0 ;
11059 bool result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 char * kwnames[] = {
11065 (char *) "self",(char *) "other", NULL
11066 };
11067
11068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11070 if (!SWIG_IsOK(res1)) {
11071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11072 }
11073 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11074 arg2 = obj1;
11075 {
11076 result = (bool)wxRect2D___ne__(arg1,arg2);
11077 if (PyErr_Occurred()) SWIG_fail;
11078 }
11079 {
11080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11081 }
11082 return resultobj;
11083 fail:
11084 return NULL;
11085 }
11086
11087
11088 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11089 PyObject *resultobj = 0;
11090 wxRect2D *arg1 = (wxRect2D *) 0 ;
11091 wxDouble arg2 ;
11092 void *argp1 = 0 ;
11093 int res1 = 0 ;
11094 void *argp2 ;
11095 int res2 = 0 ;
11096 PyObject *swig_obj[2] ;
11097
11098 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11100 if (!SWIG_IsOK(res1)) {
11101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11102 }
11103 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11104 {
11105 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11106 if (!SWIG_IsOK(res2)) {
11107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11108 }
11109 if (!argp2) {
11110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11111 } else {
11112 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11113 arg2 = *temp;
11114 if (SWIG_IsNewObj(res2)) delete temp;
11115 }
11116 }
11117 if (arg1) (arg1)->m_x = arg2;
11118
11119 resultobj = SWIG_Py_Void();
11120 return resultobj;
11121 fail:
11122 return NULL;
11123 }
11124
11125
11126 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11127 PyObject *resultobj = 0;
11128 wxRect2D *arg1 = (wxRect2D *) 0 ;
11129 wxDouble result;
11130 void *argp1 = 0 ;
11131 int res1 = 0 ;
11132 PyObject *swig_obj[1] ;
11133
11134 if (!args) SWIG_fail;
11135 swig_obj[0] = args;
11136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11137 if (!SWIG_IsOK(res1)) {
11138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11139 }
11140 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11141 result = ((arg1)->m_x);
11142 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11143 return resultobj;
11144 fail:
11145 return NULL;
11146 }
11147
11148
11149 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11150 PyObject *resultobj = 0;
11151 wxRect2D *arg1 = (wxRect2D *) 0 ;
11152 wxDouble arg2 ;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 void *argp2 ;
11156 int res2 = 0 ;
11157 PyObject *swig_obj[2] ;
11158
11159 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11161 if (!SWIG_IsOK(res1)) {
11162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11163 }
11164 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11165 {
11166 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11167 if (!SWIG_IsOK(res2)) {
11168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11169 }
11170 if (!argp2) {
11171 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11172 } else {
11173 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11174 arg2 = *temp;
11175 if (SWIG_IsNewObj(res2)) delete temp;
11176 }
11177 }
11178 if (arg1) (arg1)->m_y = arg2;
11179
11180 resultobj = SWIG_Py_Void();
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11188 PyObject *resultobj = 0;
11189 wxRect2D *arg1 = (wxRect2D *) 0 ;
11190 wxDouble result;
11191 void *argp1 = 0 ;
11192 int res1 = 0 ;
11193 PyObject *swig_obj[1] ;
11194
11195 if (!args) SWIG_fail;
11196 swig_obj[0] = args;
11197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11198 if (!SWIG_IsOK(res1)) {
11199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11200 }
11201 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11202 result = ((arg1)->m_y);
11203 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11204 return resultobj;
11205 fail:
11206 return NULL;
11207 }
11208
11209
11210 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11211 PyObject *resultobj = 0;
11212 wxRect2D *arg1 = (wxRect2D *) 0 ;
11213 wxDouble arg2 ;
11214 void *argp1 = 0 ;
11215 int res1 = 0 ;
11216 void *argp2 ;
11217 int res2 = 0 ;
11218 PyObject *swig_obj[2] ;
11219
11220 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11224 }
11225 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11226 {
11227 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11228 if (!SWIG_IsOK(res2)) {
11229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11230 }
11231 if (!argp2) {
11232 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11233 } else {
11234 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11235 arg2 = *temp;
11236 if (SWIG_IsNewObj(res2)) delete temp;
11237 }
11238 }
11239 if (arg1) (arg1)->m_width = arg2;
11240
11241 resultobj = SWIG_Py_Void();
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11249 PyObject *resultobj = 0;
11250 wxRect2D *arg1 = (wxRect2D *) 0 ;
11251 wxDouble result;
11252 void *argp1 = 0 ;
11253 int res1 = 0 ;
11254 PyObject *swig_obj[1] ;
11255
11256 if (!args) SWIG_fail;
11257 swig_obj[0] = args;
11258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11259 if (!SWIG_IsOK(res1)) {
11260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11261 }
11262 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11263 result = ((arg1)->m_width);
11264 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11272 PyObject *resultobj = 0;
11273 wxRect2D *arg1 = (wxRect2D *) 0 ;
11274 wxDouble arg2 ;
11275 void *argp1 = 0 ;
11276 int res1 = 0 ;
11277 void *argp2 ;
11278 int res2 = 0 ;
11279 PyObject *swig_obj[2] ;
11280
11281 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11285 }
11286 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11287 {
11288 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11289 if (!SWIG_IsOK(res2)) {
11290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11291 }
11292 if (!argp2) {
11293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11294 } else {
11295 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11296 arg2 = *temp;
11297 if (SWIG_IsNewObj(res2)) delete temp;
11298 }
11299 }
11300 if (arg1) (arg1)->m_height = arg2;
11301
11302 resultobj = SWIG_Py_Void();
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11310 PyObject *resultobj = 0;
11311 wxRect2D *arg1 = (wxRect2D *) 0 ;
11312 wxDouble result;
11313 void *argp1 = 0 ;
11314 int res1 = 0 ;
11315 PyObject *swig_obj[1] ;
11316
11317 if (!args) SWIG_fail;
11318 swig_obj[0] = args;
11319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11320 if (!SWIG_IsOK(res1)) {
11321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11322 }
11323 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11324 result = ((arg1)->m_height);
11325 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11326 return resultobj;
11327 fail:
11328 return NULL;
11329 }
11330
11331
11332 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11333 PyObject *resultobj = 0;
11334 wxRect2D *arg1 = (wxRect2D *) 0 ;
11335 wxDouble arg2 = (wxDouble) 0 ;
11336 wxDouble arg3 = (wxDouble) 0 ;
11337 wxDouble arg4 = (wxDouble) 0 ;
11338 wxDouble arg5 = (wxDouble) 0 ;
11339 void *argp1 = 0 ;
11340 int res1 = 0 ;
11341 void *argp2 ;
11342 int res2 = 0 ;
11343 void *argp3 ;
11344 int res3 = 0 ;
11345 void *argp4 ;
11346 int res4 = 0 ;
11347 void *argp5 ;
11348 int res5 = 0 ;
11349 PyObject * obj0 = 0 ;
11350 PyObject * obj1 = 0 ;
11351 PyObject * obj2 = 0 ;
11352 PyObject * obj3 = 0 ;
11353 PyObject * obj4 = 0 ;
11354 char * kwnames[] = {
11355 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11356 };
11357
11358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11360 if (!SWIG_IsOK(res1)) {
11361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11362 }
11363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11364 if (obj1) {
11365 {
11366 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11367 if (!SWIG_IsOK(res2)) {
11368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11369 }
11370 if (!argp2) {
11371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11372 } else {
11373 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11374 arg2 = *temp;
11375 if (SWIG_IsNewObj(res2)) delete temp;
11376 }
11377 }
11378 }
11379 if (obj2) {
11380 {
11381 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11382 if (!SWIG_IsOK(res3)) {
11383 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11384 }
11385 if (!argp3) {
11386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11387 } else {
11388 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11389 arg3 = *temp;
11390 if (SWIG_IsNewObj(res3)) delete temp;
11391 }
11392 }
11393 }
11394 if (obj3) {
11395 {
11396 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11397 if (!SWIG_IsOK(res4)) {
11398 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11399 }
11400 if (!argp4) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11402 } else {
11403 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11404 arg4 = *temp;
11405 if (SWIG_IsNewObj(res4)) delete temp;
11406 }
11407 }
11408 }
11409 if (obj4) {
11410 {
11411 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11412 if (!SWIG_IsOK(res5)) {
11413 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11414 }
11415 if (!argp5) {
11416 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11417 } else {
11418 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11419 arg5 = *temp;
11420 if (SWIG_IsNewObj(res5)) delete temp;
11421 }
11422 }
11423 }
11424 {
11425 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 resultobj = SWIG_Py_Void();
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11436 PyObject *resultobj = 0;
11437 wxRect2D *arg1 = (wxRect2D *) 0 ;
11438 PyObject *result = 0 ;
11439 void *argp1 = 0 ;
11440 int res1 = 0 ;
11441 PyObject *swig_obj[1] ;
11442
11443 if (!args) SWIG_fail;
11444 swig_obj[0] = args;
11445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11446 if (!SWIG_IsOK(res1)) {
11447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11448 }
11449 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11450 {
11451 result = (PyObject *)wxRect2D_Get(arg1);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 resultobj = result;
11455 return resultobj;
11456 fail:
11457 return NULL;
11458 }
11459
11460
11461 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11462 PyObject *obj;
11463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11464 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11465 return SWIG_Py_Void();
11466 }
11467
11468 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 return SWIG_Python_InitShadowInstance(args);
11470 }
11471
11472 SWIGINTERN int DefaultPosition_set(PyObject *) {
11473 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11474 return 1;
11475 }
11476
11477
11478 SWIGINTERN PyObject *DefaultPosition_get(void) {
11479 PyObject *pyobj = 0;
11480
11481 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11482 return pyobj;
11483 }
11484
11485
11486 SWIGINTERN int DefaultSize_set(PyObject *) {
11487 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11488 return 1;
11489 }
11490
11491
11492 SWIGINTERN PyObject *DefaultSize_get(void) {
11493 PyObject *pyobj = 0;
11494
11495 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11496 return pyobj;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj = 0;
11502 PyObject *arg1 = (PyObject *) 0 ;
11503 wxPyInputStream *result = 0 ;
11504 PyObject * obj0 = 0 ;
11505 char * kwnames[] = {
11506 (char *) "p", NULL
11507 };
11508
11509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11510 arg1 = obj0;
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11514 wxPyEndAllowThreads(__tstate);
11515 if (PyErr_Occurred()) SWIG_fail;
11516 }
11517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11518 return resultobj;
11519 fail:
11520 return NULL;
11521 }
11522
11523
11524 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11525 PyObject *resultobj = 0;
11526 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11527 void *argp1 = 0 ;
11528 int res1 = 0 ;
11529 PyObject *swig_obj[1] ;
11530
11531 if (!args) SWIG_fail;
11532 swig_obj[0] = args;
11533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11534 if (!SWIG_IsOK(res1)) {
11535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11536 }
11537 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11538 {
11539 PyThreadState* __tstate = wxPyBeginAllowThreads();
11540 delete arg1;
11541
11542 wxPyEndAllowThreads(__tstate);
11543 if (PyErr_Occurred()) SWIG_fail;
11544 }
11545 resultobj = SWIG_Py_Void();
11546 return resultobj;
11547 fail:
11548 return NULL;
11549 }
11550
11551
11552 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11553 PyObject *resultobj = 0;
11554 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11555 void *argp1 = 0 ;
11556 int res1 = 0 ;
11557 PyObject *swig_obj[1] ;
11558
11559 if (!args) SWIG_fail;
11560 swig_obj[0] = args;
11561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11562 if (!SWIG_IsOK(res1)) {
11563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11564 }
11565 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11566 {
11567 PyThreadState* __tstate = wxPyBeginAllowThreads();
11568 (arg1)->close();
11569 wxPyEndAllowThreads(__tstate);
11570 if (PyErr_Occurred()) SWIG_fail;
11571 }
11572 resultobj = SWIG_Py_Void();
11573 return resultobj;
11574 fail:
11575 return NULL;
11576 }
11577
11578
11579 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11580 PyObject *resultobj = 0;
11581 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11582 void *argp1 = 0 ;
11583 int res1 = 0 ;
11584 PyObject *swig_obj[1] ;
11585
11586 if (!args) SWIG_fail;
11587 swig_obj[0] = args;
11588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11589 if (!SWIG_IsOK(res1)) {
11590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11591 }
11592 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 (arg1)->flush();
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 resultobj = SWIG_Py_Void();
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607 PyObject *resultobj = 0;
11608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11609 bool result;
11610 void *argp1 = 0 ;
11611 int res1 = 0 ;
11612 PyObject *swig_obj[1] ;
11613
11614 if (!args) SWIG_fail;
11615 swig_obj[0] = args;
11616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11617 if (!SWIG_IsOK(res1)) {
11618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11619 }
11620 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11621 {
11622 PyThreadState* __tstate = wxPyBeginAllowThreads();
11623 result = (bool)(arg1)->eof();
11624 wxPyEndAllowThreads(__tstate);
11625 if (PyErr_Occurred()) SWIG_fail;
11626 }
11627 {
11628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11629 }
11630 return resultobj;
11631 fail:
11632 return NULL;
11633 }
11634
11635
11636 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11637 PyObject *resultobj = 0;
11638 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11639 int arg2 = (int) -1 ;
11640 PyObject *result = 0 ;
11641 void *argp1 = 0 ;
11642 int res1 = 0 ;
11643 int val2 ;
11644 int ecode2 = 0 ;
11645 PyObject * obj0 = 0 ;
11646 PyObject * obj1 = 0 ;
11647 char * kwnames[] = {
11648 (char *) "self",(char *) "size", NULL
11649 };
11650
11651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11655 }
11656 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11657 if (obj1) {
11658 ecode2 = SWIG_AsVal_int(obj1, &val2);
11659 if (!SWIG_IsOK(ecode2)) {
11660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11661 }
11662 arg2 = static_cast< int >(val2);
11663 }
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (PyObject *)(arg1)->read(arg2);
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 resultobj = result;
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj = 0;
11679 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11680 int arg2 = (int) -1 ;
11681 PyObject *result = 0 ;
11682 void *argp1 = 0 ;
11683 int res1 = 0 ;
11684 int val2 ;
11685 int ecode2 = 0 ;
11686 PyObject * obj0 = 0 ;
11687 PyObject * obj1 = 0 ;
11688 char * kwnames[] = {
11689 (char *) "self",(char *) "size", NULL
11690 };
11691
11692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11696 }
11697 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11698 if (obj1) {
11699 ecode2 = SWIG_AsVal_int(obj1, &val2);
11700 if (!SWIG_IsOK(ecode2)) {
11701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11702 }
11703 arg2 = static_cast< int >(val2);
11704 }
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (PyObject *)(arg1)->readline(arg2);
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 resultobj = result;
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11719 PyObject *resultobj = 0;
11720 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11721 int arg2 = (int) -1 ;
11722 PyObject *result = 0 ;
11723 void *argp1 = 0 ;
11724 int res1 = 0 ;
11725 int val2 ;
11726 int ecode2 = 0 ;
11727 PyObject * obj0 = 0 ;
11728 PyObject * obj1 = 0 ;
11729 char * kwnames[] = {
11730 (char *) "self",(char *) "sizehint", NULL
11731 };
11732
11733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11737 }
11738 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11739 if (obj1) {
11740 ecode2 = SWIG_AsVal_int(obj1, &val2);
11741 if (!SWIG_IsOK(ecode2)) {
11742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11743 }
11744 arg2 = static_cast< int >(val2);
11745 }
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (PyObject *)(arg1)->readlines(arg2);
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 resultobj = result;
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11760 PyObject *resultobj = 0;
11761 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11762 int arg2 ;
11763 int arg3 = (int) 0 ;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 int val2 ;
11767 int ecode2 = 0 ;
11768 int val3 ;
11769 int ecode3 = 0 ;
11770 PyObject * obj0 = 0 ;
11771 PyObject * obj1 = 0 ;
11772 PyObject * obj2 = 0 ;
11773 char * kwnames[] = {
11774 (char *) "self",(char *) "offset",(char *) "whence", NULL
11775 };
11776
11777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11779 if (!SWIG_IsOK(res1)) {
11780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11781 }
11782 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11783 ecode2 = SWIG_AsVal_int(obj1, &val2);
11784 if (!SWIG_IsOK(ecode2)) {
11785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11786 }
11787 arg2 = static_cast< int >(val2);
11788 if (obj2) {
11789 ecode3 = SWIG_AsVal_int(obj2, &val3);
11790 if (!SWIG_IsOK(ecode3)) {
11791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11792 }
11793 arg3 = static_cast< int >(val3);
11794 }
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 (arg1)->seek(arg2,arg3);
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 resultobj = SWIG_Py_Void();
11802 return resultobj;
11803 fail:
11804 return NULL;
11805 }
11806
11807
11808 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11809 PyObject *resultobj = 0;
11810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11811 int result;
11812 void *argp1 = 0 ;
11813 int res1 = 0 ;
11814 PyObject *swig_obj[1] ;
11815
11816 if (!args) SWIG_fail;
11817 swig_obj[0] = args;
11818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11819 if (!SWIG_IsOK(res1)) {
11820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11821 }
11822 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 result = (int)(arg1)->tell();
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 resultobj = SWIG_From_int(static_cast< int >(result));
11830 return resultobj;
11831 fail:
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11837 PyObject *resultobj = 0;
11838 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11839 char result;
11840 void *argp1 = 0 ;
11841 int res1 = 0 ;
11842 PyObject *swig_obj[1] ;
11843
11844 if (!args) SWIG_fail;
11845 swig_obj[0] = args;
11846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11847 if (!SWIG_IsOK(res1)) {
11848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11849 }
11850 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (char)(arg1)->Peek();
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 resultobj = SWIG_From_char(static_cast< char >(result));
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11867 char result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11877 }
11878 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (char)(arg1)->GetC();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 resultobj = SWIG_From_char(static_cast< char >(result));
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 PyObject *resultobj = 0;
11894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11895 size_t result;
11896 void *argp1 = 0 ;
11897 int res1 = 0 ;
11898 PyObject *swig_obj[1] ;
11899
11900 if (!args) SWIG_fail;
11901 swig_obj[0] = args;
11902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11905 }
11906 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (size_t)(arg1)->LastRead();
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11914 return resultobj;
11915 fail:
11916 return NULL;
11917 }
11918
11919
11920 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11921 PyObject *resultobj = 0;
11922 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11923 bool result;
11924 void *argp1 = 0 ;
11925 int res1 = 0 ;
11926 PyObject *swig_obj[1] ;
11927
11928 if (!args) SWIG_fail;
11929 swig_obj[0] = args;
11930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11931 if (!SWIG_IsOK(res1)) {
11932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11933 }
11934 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (bool)(arg1)->CanRead();
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11943 }
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11951 PyObject *resultobj = 0;
11952 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11953 bool result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 PyObject *swig_obj[1] ;
11957
11958 if (!args) SWIG_fail;
11959 swig_obj[0] = args;
11960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11963 }
11964 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (bool)(arg1)->Eof();
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 {
11972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11973 }
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj = 0;
11982 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11983 char arg2 ;
11984 bool result;
11985 void *argp1 = 0 ;
11986 int res1 = 0 ;
11987 char val2 ;
11988 int ecode2 = 0 ;
11989 PyObject * obj0 = 0 ;
11990 PyObject * obj1 = 0 ;
11991 char * kwnames[] = {
11992 (char *) "self",(char *) "c", NULL
11993 };
11994
11995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11997 if (!SWIG_IsOK(res1)) {
11998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11999 }
12000 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12001 ecode2 = SWIG_AsVal_char(obj1, &val2);
12002 if (!SWIG_IsOK(ecode2)) {
12003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12004 }
12005 arg2 = static_cast< char >(val2);
12006 {
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (bool)(arg1)->Ungetch(arg2);
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj = 0;
12023 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12024 long arg2 ;
12025 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12026 long result;
12027 void *argp1 = 0 ;
12028 int res1 = 0 ;
12029 long val2 ;
12030 int ecode2 = 0 ;
12031 int val3 ;
12032 int ecode3 = 0 ;
12033 PyObject * obj0 = 0 ;
12034 PyObject * obj1 = 0 ;
12035 PyObject * obj2 = 0 ;
12036 char * kwnames[] = {
12037 (char *) "self",(char *) "pos",(char *) "mode", NULL
12038 };
12039
12040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12042 if (!SWIG_IsOK(res1)) {
12043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12044 }
12045 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12046 ecode2 = SWIG_AsVal_long(obj1, &val2);
12047 if (!SWIG_IsOK(ecode2)) {
12048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12049 }
12050 arg2 = static_cast< long >(val2);
12051 if (obj2) {
12052 ecode3 = SWIG_AsVal_int(obj2, &val3);
12053 if (!SWIG_IsOK(ecode3)) {
12054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12055 }
12056 arg3 = static_cast< wxSeekMode >(val3);
12057 }
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 result = (long)(arg1)->SeekI(arg2,arg3);
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 resultobj = SWIG_From_long(static_cast< long >(result));
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12072 PyObject *resultobj = 0;
12073 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12074 long result;
12075 void *argp1 = 0 ;
12076 int res1 = 0 ;
12077 PyObject *swig_obj[1] ;
12078
12079 if (!args) SWIG_fail;
12080 swig_obj[0] = args;
12081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12082 if (!SWIG_IsOK(res1)) {
12083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12084 }
12085 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (long)(arg1)->TellI();
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 resultobj = SWIG_From_long(static_cast< long >(result));
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12100 PyObject *obj;
12101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12102 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12103 return SWIG_Py_Void();
12104 }
12105
12106 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 return SWIG_Python_InitShadowInstance(args);
12108 }
12109
12110 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12111 PyObject *resultobj = 0;
12112 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12113 PyObject *arg2 = (PyObject *) 0 ;
12114 void *argp1 = 0 ;
12115 int res1 = 0 ;
12116 PyObject * obj0 = 0 ;
12117 PyObject * obj1 = 0 ;
12118 char * kwnames[] = {
12119 (char *) "self",(char *) "obj", NULL
12120 };
12121
12122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12124 if (!SWIG_IsOK(res1)) {
12125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12126 }
12127 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12128 arg2 = obj1;
12129 {
12130 PyThreadState* __tstate = wxPyBeginAllowThreads();
12131 wxOutputStream_write(arg1,arg2);
12132 wxPyEndAllowThreads(__tstate);
12133 if (PyErr_Occurred()) SWIG_fail;
12134 }
12135 resultobj = SWIG_Py_Void();
12136 return resultobj;
12137 fail:
12138 return NULL;
12139 }
12140
12141
12142 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12143 PyObject *resultobj = 0;
12144 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12145 size_t result;
12146 void *argp1 = 0 ;
12147 int res1 = 0 ;
12148 PyObject *swig_obj[1] ;
12149
12150 if (!args) SWIG_fail;
12151 swig_obj[0] = args;
12152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12153 if (!SWIG_IsOK(res1)) {
12154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12155 }
12156 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171 PyObject *obj;
12172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12173 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12174 return SWIG_Py_Void();
12175 }
12176
12177 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12178 PyObject *resultobj = 0;
12179 wxInputStream *arg1 = (wxInputStream *) 0 ;
12180 wxString *arg2 = 0 ;
12181 wxString *arg3 = 0 ;
12182 wxString *arg4 = 0 ;
12183 wxDateTime arg5 ;
12184 wxFSFile *result = 0 ;
12185 wxPyInputStream *temp1 ;
12186 bool temp2 = false ;
12187 bool temp3 = false ;
12188 bool temp4 = false ;
12189 void *argp5 ;
12190 int res5 = 0 ;
12191 PyObject * obj0 = 0 ;
12192 PyObject * obj1 = 0 ;
12193 PyObject * obj2 = 0 ;
12194 PyObject * obj3 = 0 ;
12195 PyObject * obj4 = 0 ;
12196 char * kwnames[] = {
12197 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12198 };
12199
12200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12201 {
12202 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12203 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12204 } else {
12205 PyErr_Clear(); // clear the failure of the wxPyConvert above
12206 arg1 = wxPyCBInputStream_create(obj0, true);
12207 if (arg1 == NULL) {
12208 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12209 SWIG_fail;
12210 }
12211 }
12212 }
12213 {
12214 arg2 = wxString_in_helper(obj1);
12215 if (arg2 == NULL) SWIG_fail;
12216 temp2 = true;
12217 }
12218 {
12219 arg3 = wxString_in_helper(obj2);
12220 if (arg3 == NULL) SWIG_fail;
12221 temp3 = true;
12222 }
12223 {
12224 arg4 = wxString_in_helper(obj3);
12225 if (arg4 == NULL) SWIG_fail;
12226 temp4 = true;
12227 }
12228 {
12229 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12230 if (!SWIG_IsOK(res5)) {
12231 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12232 }
12233 if (!argp5) {
12234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12235 } else {
12236 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12237 arg5 = *temp;
12238 if (SWIG_IsNewObj(res5)) delete temp;
12239 }
12240 }
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12248 {
12249 if (temp2)
12250 delete arg2;
12251 }
12252 {
12253 if (temp3)
12254 delete arg3;
12255 }
12256 {
12257 if (temp4)
12258 delete arg4;
12259 }
12260 return resultobj;
12261 fail:
12262 {
12263 if (temp2)
12264 delete arg2;
12265 }
12266 {
12267 if (temp3)
12268 delete arg3;
12269 }
12270 {
12271 if (temp4)
12272 delete arg4;
12273 }
12274 return NULL;
12275 }
12276
12277
12278 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12279 PyObject *resultobj = 0;
12280 wxFSFile *arg1 = (wxFSFile *) 0 ;
12281 void *argp1 = 0 ;
12282 int res1 = 0 ;
12283 PyObject *swig_obj[1] ;
12284
12285 if (!args) SWIG_fail;
12286 swig_obj[0] = args;
12287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12288 if (!SWIG_IsOK(res1)) {
12289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12290 }
12291 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 delete arg1;
12295
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 resultobj = SWIG_Py_Void();
12300 return resultobj;
12301 fail:
12302 return NULL;
12303 }
12304
12305
12306 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12307 PyObject *resultobj = 0;
12308 wxFSFile *arg1 = (wxFSFile *) 0 ;
12309 wxInputStream *result = 0 ;
12310 void *argp1 = 0 ;
12311 int res1 = 0 ;
12312 PyObject *swig_obj[1] ;
12313
12314 if (!args) SWIG_fail;
12315 swig_obj[0] = args;
12316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12319 }
12320 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (wxInputStream *)(arg1)->GetStream();
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 {
12328 wxPyInputStream * _ptr = NULL;
12329
12330 if (result) {
12331 _ptr = new wxPyInputStream(result);
12332 }
12333 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12334 }
12335 return resultobj;
12336 fail:
12337 return NULL;
12338 }
12339
12340
12341 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12342 PyObject *resultobj = 0;
12343 wxFSFile *arg1 = (wxFSFile *) 0 ;
12344 void *argp1 = 0 ;
12345 int res1 = 0 ;
12346 PyObject *swig_obj[1] ;
12347
12348 if (!args) SWIG_fail;
12349 swig_obj[0] = args;
12350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12351 if (!SWIG_IsOK(res1)) {
12352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12353 }
12354 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 (arg1)->DetachStream();
12358 wxPyEndAllowThreads(__tstate);
12359 if (PyErr_Occurred()) SWIG_fail;
12360 }
12361 resultobj = SWIG_Py_Void();
12362 return resultobj;
12363 fail:
12364 return NULL;
12365 }
12366
12367
12368 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12369 PyObject *resultobj = 0;
12370 wxFSFile *arg1 = (wxFSFile *) 0 ;
12371 wxString *result = 0 ;
12372 void *argp1 = 0 ;
12373 int res1 = 0 ;
12374 PyObject *swig_obj[1] ;
12375
12376 if (!args) SWIG_fail;
12377 swig_obj[0] = args;
12378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12379 if (!SWIG_IsOK(res1)) {
12380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12381 }
12382 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 {
12386 wxString const &_result_ref = (arg1)->GetMimeType();
12387 result = (wxString *) &_result_ref;
12388 }
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 #if wxUSE_UNICODE
12394 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12395 #else
12396 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12397 #endif
12398 }
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406 PyObject *resultobj = 0;
12407 wxFSFile *arg1 = (wxFSFile *) 0 ;
12408 wxString *result = 0 ;
12409 void *argp1 = 0 ;
12410 int res1 = 0 ;
12411 PyObject *swig_obj[1] ;
12412
12413 if (!args) SWIG_fail;
12414 swig_obj[0] = args;
12415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12416 if (!SWIG_IsOK(res1)) {
12417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12418 }
12419 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 {
12423 wxString const &_result_ref = (arg1)->GetLocation();
12424 result = (wxString *) &_result_ref;
12425 }
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 {
12430 #if wxUSE_UNICODE
12431 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12432 #else
12433 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12434 #endif
12435 }
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443 PyObject *resultobj = 0;
12444 wxFSFile *arg1 = (wxFSFile *) 0 ;
12445 wxString *result = 0 ;
12446 void *argp1 = 0 ;
12447 int res1 = 0 ;
12448 PyObject *swig_obj[1] ;
12449
12450 if (!args) SWIG_fail;
12451 swig_obj[0] = args;
12452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12455 }
12456 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 {
12460 wxString const &_result_ref = (arg1)->GetAnchor();
12461 result = (wxString *) &_result_ref;
12462 }
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 {
12467 #if wxUSE_UNICODE
12468 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12469 #else
12470 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12471 #endif
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12480 PyObject *resultobj = 0;
12481 wxFSFile *arg1 = (wxFSFile *) 0 ;
12482 wxDateTime result;
12483 void *argp1 = 0 ;
12484 int res1 = 0 ;
12485 PyObject *swig_obj[1] ;
12486
12487 if (!args) SWIG_fail;
12488 swig_obj[0] = args;
12489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12490 if (!SWIG_IsOK(res1)) {
12491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12492 }
12493 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (arg1)->GetModificationTime();
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12508 PyObject *obj;
12509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12510 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12511 return SWIG_Py_Void();
12512 }
12513
12514 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 return SWIG_Python_InitShadowInstance(args);
12516 }
12517
12518 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12519 PyObject *resultobj = 0;
12520 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12521 void *argp1 = 0 ;
12522 int res1 = 0 ;
12523 PyObject *swig_obj[1] ;
12524
12525 if (!args) SWIG_fail;
12526 swig_obj[0] = args;
12527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12528 if (!SWIG_IsOK(res1)) {
12529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12530 }
12531 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12532 {
12533 PyThreadState* __tstate = wxPyBeginAllowThreads();
12534 delete arg1;
12535
12536 wxPyEndAllowThreads(__tstate);
12537 if (PyErr_Occurred()) SWIG_fail;
12538 }
12539 resultobj = SWIG_Py_Void();
12540 return resultobj;
12541 fail:
12542 return NULL;
12543 }
12544
12545
12546 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12547 PyObject *obj;
12548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12549 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12550 return SWIG_Py_Void();
12551 }
12552
12553 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12554 PyObject *resultobj = 0;
12555 wxPyFileSystemHandler *result = 0 ;
12556
12557 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12572 PyObject *resultobj = 0;
12573 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12574 PyObject *arg2 = (PyObject *) 0 ;
12575 PyObject *arg3 = (PyObject *) 0 ;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 PyObject * obj0 = 0 ;
12579 PyObject * obj1 = 0 ;
12580 PyObject * obj2 = 0 ;
12581 char * kwnames[] = {
12582 (char *) "self",(char *) "self",(char *) "_class", NULL
12583 };
12584
12585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12587 if (!SWIG_IsOK(res1)) {
12588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12589 }
12590 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12591 arg2 = obj1;
12592 arg3 = obj2;
12593 {
12594 PyThreadState* __tstate = wxPyBeginAllowThreads();
12595 (arg1)->_setCallbackInfo(arg2,arg3);
12596 wxPyEndAllowThreads(__tstate);
12597 if (PyErr_Occurred()) SWIG_fail;
12598 }
12599 resultobj = SWIG_Py_Void();
12600 return resultobj;
12601 fail:
12602 return NULL;
12603 }
12604
12605
12606 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12607 PyObject *resultobj = 0;
12608 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12609 wxString *arg2 = 0 ;
12610 bool result;
12611 void *argp1 = 0 ;
12612 int res1 = 0 ;
12613 bool temp2 = false ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 char * kwnames[] = {
12617 (char *) "self",(char *) "location", NULL
12618 };
12619
12620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12622 if (!SWIG_IsOK(res1)) {
12623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12624 }
12625 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12626 {
12627 arg2 = wxString_in_helper(obj1);
12628 if (arg2 == NULL) SWIG_fail;
12629 temp2 = true;
12630 }
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12634 wxPyEndAllowThreads(__tstate);
12635 if (PyErr_Occurred()) SWIG_fail;
12636 }
12637 {
12638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12639 }
12640 {
12641 if (temp2)
12642 delete arg2;
12643 }
12644 return resultobj;
12645 fail:
12646 {
12647 if (temp2)
12648 delete arg2;
12649 }
12650 return NULL;
12651 }
12652
12653
12654 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12655 PyObject *resultobj = 0;
12656 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12657 wxFileSystem *arg2 = 0 ;
12658 wxString *arg3 = 0 ;
12659 wxFSFile *result = 0 ;
12660 void *argp1 = 0 ;
12661 int res1 = 0 ;
12662 void *argp2 = 0 ;
12663 int res2 = 0 ;
12664 bool temp3 = false ;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 PyObject * obj2 = 0 ;
12668 char * kwnames[] = {
12669 (char *) "self",(char *) "fs",(char *) "location", NULL
12670 };
12671
12672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12674 if (!SWIG_IsOK(res1)) {
12675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12676 }
12677 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12679 if (!SWIG_IsOK(res2)) {
12680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12681 }
12682 if (!argp2) {
12683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12684 }
12685 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12686 {
12687 arg3 = wxString_in_helper(obj2);
12688 if (arg3 == NULL) SWIG_fail;
12689 temp3 = true;
12690 }
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 {
12698 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12699 }
12700 {
12701 if (temp3)
12702 delete arg3;
12703 }
12704 return resultobj;
12705 fail:
12706 {
12707 if (temp3)
12708 delete arg3;
12709 }
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj = 0;
12716 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12717 wxString *arg2 = 0 ;
12718 int arg3 = (int) 0 ;
12719 wxString result;
12720 void *argp1 = 0 ;
12721 int res1 = 0 ;
12722 bool temp2 = false ;
12723 int val3 ;
12724 int ecode3 = 0 ;
12725 PyObject * obj0 = 0 ;
12726 PyObject * obj1 = 0 ;
12727 PyObject * obj2 = 0 ;
12728 char * kwnames[] = {
12729 (char *) "self",(char *) "spec",(char *) "flags", NULL
12730 };
12731
12732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12734 if (!SWIG_IsOK(res1)) {
12735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12736 }
12737 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12738 {
12739 arg2 = wxString_in_helper(obj1);
12740 if (arg2 == NULL) SWIG_fail;
12741 temp2 = true;
12742 }
12743 if (obj2) {
12744 ecode3 = SWIG_AsVal_int(obj2, &val3);
12745 if (!SWIG_IsOK(ecode3)) {
12746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12747 }
12748 arg3 = static_cast< int >(val3);
12749 }
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 {
12757 #if wxUSE_UNICODE
12758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12759 #else
12760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12761 #endif
12762 }
12763 {
12764 if (temp2)
12765 delete arg2;
12766 }
12767 return resultobj;
12768 fail:
12769 {
12770 if (temp2)
12771 delete arg2;
12772 }
12773 return NULL;
12774 }
12775
12776
12777 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12778 PyObject *resultobj = 0;
12779 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12780 wxString result;
12781 void *argp1 = 0 ;
12782 int res1 = 0 ;
12783 PyObject *swig_obj[1] ;
12784
12785 if (!args) SWIG_fail;
12786 swig_obj[0] = args;
12787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12788 if (!SWIG_IsOK(res1)) {
12789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12790 }
12791 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12792 {
12793 PyThreadState* __tstate = wxPyBeginAllowThreads();
12794 result = (arg1)->FindNext();
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 {
12799 #if wxUSE_UNICODE
12800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12801 #else
12802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12803 #endif
12804 }
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12812 PyObject *resultobj = 0;
12813 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12814 wxString *arg2 = 0 ;
12815 wxString result;
12816 void *argp1 = 0 ;
12817 int res1 = 0 ;
12818 bool temp2 = false ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 char * kwnames[] = {
12822 (char *) "self",(char *) "location", NULL
12823 };
12824
12825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12827 if (!SWIG_IsOK(res1)) {
12828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12829 }
12830 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12831 {
12832 arg2 = wxString_in_helper(obj1);
12833 if (arg2 == NULL) SWIG_fail;
12834 temp2 = true;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 result = (arg1)->GetProtocol((wxString const &)*arg2);
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 {
12843 #if wxUSE_UNICODE
12844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12845 #else
12846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12847 #endif
12848 }
12849 {
12850 if (temp2)
12851 delete arg2;
12852 }
12853 return resultobj;
12854 fail:
12855 {
12856 if (temp2)
12857 delete arg2;
12858 }
12859 return NULL;
12860 }
12861
12862
12863 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12864 PyObject *resultobj = 0;
12865 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12866 wxString *arg2 = 0 ;
12867 wxString result;
12868 void *argp1 = 0 ;
12869 int res1 = 0 ;
12870 bool temp2 = false ;
12871 PyObject * obj0 = 0 ;
12872 PyObject * obj1 = 0 ;
12873 char * kwnames[] = {
12874 (char *) "self",(char *) "location", NULL
12875 };
12876
12877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12879 if (!SWIG_IsOK(res1)) {
12880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12881 }
12882 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12883 {
12884 arg2 = wxString_in_helper(obj1);
12885 if (arg2 == NULL) SWIG_fail;
12886 temp2 = true;
12887 }
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12891 wxPyEndAllowThreads(__tstate);
12892 if (PyErr_Occurred()) SWIG_fail;
12893 }
12894 {
12895 #if wxUSE_UNICODE
12896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12897 #else
12898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12899 #endif
12900 }
12901 {
12902 if (temp2)
12903 delete arg2;
12904 }
12905 return resultobj;
12906 fail:
12907 {
12908 if (temp2)
12909 delete arg2;
12910 }
12911 return NULL;
12912 }
12913
12914
12915 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj = 0;
12917 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12918 wxString *arg2 = 0 ;
12919 wxString result;
12920 void *argp1 = 0 ;
12921 int res1 = 0 ;
12922 bool temp2 = false ;
12923 PyObject * obj0 = 0 ;
12924 PyObject * obj1 = 0 ;
12925 char * kwnames[] = {
12926 (char *) "self",(char *) "location", NULL
12927 };
12928
12929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12931 if (!SWIG_IsOK(res1)) {
12932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12933 }
12934 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12935 {
12936 arg2 = wxString_in_helper(obj1);
12937 if (arg2 == NULL) SWIG_fail;
12938 temp2 = true;
12939 }
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (arg1)->GetAnchor((wxString const &)*arg2);
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 #if wxUSE_UNICODE
12948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12949 #else
12950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12951 #endif
12952 }
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return resultobj;
12958 fail:
12959 {
12960 if (temp2)
12961 delete arg2;
12962 }
12963 return NULL;
12964 }
12965
12966
12967 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12968 PyObject *resultobj = 0;
12969 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12970 wxString *arg2 = 0 ;
12971 wxString result;
12972 void *argp1 = 0 ;
12973 int res1 = 0 ;
12974 bool temp2 = false ;
12975 PyObject * obj0 = 0 ;
12976 PyObject * obj1 = 0 ;
12977 char * kwnames[] = {
12978 (char *) "self",(char *) "location", NULL
12979 };
12980
12981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12983 if (!SWIG_IsOK(res1)) {
12984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12985 }
12986 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12987 {
12988 arg2 = wxString_in_helper(obj1);
12989 if (arg2 == NULL) SWIG_fail;
12990 temp2 = true;
12991 }
12992 {
12993 PyThreadState* __tstate = wxPyBeginAllowThreads();
12994 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 {
12999 #if wxUSE_UNICODE
13000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13001 #else
13002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13003 #endif
13004 }
13005 {
13006 if (temp2)
13007 delete arg2;
13008 }
13009 return resultobj;
13010 fail:
13011 {
13012 if (temp2)
13013 delete arg2;
13014 }
13015 return NULL;
13016 }
13017
13018
13019 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13020 PyObject *resultobj = 0;
13021 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13022 wxString *arg2 = 0 ;
13023 wxString result;
13024 void *argp1 = 0 ;
13025 int res1 = 0 ;
13026 bool temp2 = false ;
13027 PyObject * obj0 = 0 ;
13028 PyObject * obj1 = 0 ;
13029 char * kwnames[] = {
13030 (char *) "self",(char *) "location", NULL
13031 };
13032
13033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13035 if (!SWIG_IsOK(res1)) {
13036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13037 }
13038 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13039 {
13040 arg2 = wxString_in_helper(obj1);
13041 if (arg2 == NULL) SWIG_fail;
13042 temp2 = true;
13043 }
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 {
13051 #if wxUSE_UNICODE
13052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13053 #else
13054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13055 #endif
13056 }
13057 {
13058 if (temp2)
13059 delete arg2;
13060 }
13061 return resultobj;
13062 fail:
13063 {
13064 if (temp2)
13065 delete arg2;
13066 }
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 PyObject *obj;
13073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13074 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13075 return SWIG_Py_Void();
13076 }
13077
13078 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 return SWIG_Python_InitShadowInstance(args);
13080 }
13081
13082 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13083 PyObject *resultobj = 0;
13084 wxFileSystem *result = 0 ;
13085
13086 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 result = (wxFileSystem *)new wxFileSystem();
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13101 PyObject *resultobj = 0;
13102 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13103 void *argp1 = 0 ;
13104 int res1 = 0 ;
13105 PyObject *swig_obj[1] ;
13106
13107 if (!args) SWIG_fail;
13108 swig_obj[0] = args;
13109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13110 if (!SWIG_IsOK(res1)) {
13111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13112 }
13113 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 delete arg1;
13117
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 resultobj = SWIG_Py_Void();
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = 0;
13130 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13131 wxString *arg2 = 0 ;
13132 bool arg3 = (bool) false ;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 bool temp2 = false ;
13136 bool val3 ;
13137 int ecode3 = 0 ;
13138 PyObject * obj0 = 0 ;
13139 PyObject * obj1 = 0 ;
13140 PyObject * obj2 = 0 ;
13141 char * kwnames[] = {
13142 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13143 };
13144
13145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13147 if (!SWIG_IsOK(res1)) {
13148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13149 }
13150 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13151 {
13152 arg2 = wxString_in_helper(obj1);
13153 if (arg2 == NULL) SWIG_fail;
13154 temp2 = true;
13155 }
13156 if (obj2) {
13157 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13158 if (!SWIG_IsOK(ecode3)) {
13159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13160 }
13161 arg3 = static_cast< bool >(val3);
13162 }
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 resultobj = SWIG_Py_Void();
13170 {
13171 if (temp2)
13172 delete arg2;
13173 }
13174 return resultobj;
13175 fail:
13176 {
13177 if (temp2)
13178 delete arg2;
13179 }
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13185 PyObject *resultobj = 0;
13186 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13187 wxString result;
13188 void *argp1 = 0 ;
13189 int res1 = 0 ;
13190 PyObject *swig_obj[1] ;
13191
13192 if (!args) SWIG_fail;
13193 swig_obj[0] = args;
13194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13195 if (!SWIG_IsOK(res1)) {
13196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13197 }
13198 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13199 {
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 result = (arg1)->GetPath();
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 {
13206 #if wxUSE_UNICODE
13207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13208 #else
13209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13210 #endif
13211 }
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj = 0;
13220 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13221 wxString *arg2 = 0 ;
13222 wxFSFile *result = 0 ;
13223 void *argp1 = 0 ;
13224 int res1 = 0 ;
13225 bool temp2 = false ;
13226 PyObject * obj0 = 0 ;
13227 PyObject * obj1 = 0 ;
13228 char * kwnames[] = {
13229 (char *) "self",(char *) "location", NULL
13230 };
13231
13232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13234 if (!SWIG_IsOK(res1)) {
13235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13236 }
13237 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13238 {
13239 arg2 = wxString_in_helper(obj1);
13240 if (arg2 == NULL) SWIG_fail;
13241 temp2 = true;
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 {
13250 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13251 }
13252 {
13253 if (temp2)
13254 delete arg2;
13255 }
13256 return resultobj;
13257 fail:
13258 {
13259 if (temp2)
13260 delete arg2;
13261 }
13262 return NULL;
13263 }
13264
13265
13266 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj = 0;
13268 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13269 wxString *arg2 = 0 ;
13270 int arg3 = (int) 0 ;
13271 wxString result;
13272 void *argp1 = 0 ;
13273 int res1 = 0 ;
13274 bool temp2 = false ;
13275 int val3 ;
13276 int ecode3 = 0 ;
13277 PyObject * obj0 = 0 ;
13278 PyObject * obj1 = 0 ;
13279 PyObject * obj2 = 0 ;
13280 char * kwnames[] = {
13281 (char *) "self",(char *) "spec",(char *) "flags", NULL
13282 };
13283
13284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13286 if (!SWIG_IsOK(res1)) {
13287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13288 }
13289 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13290 {
13291 arg2 = wxString_in_helper(obj1);
13292 if (arg2 == NULL) SWIG_fail;
13293 temp2 = true;
13294 }
13295 if (obj2) {
13296 ecode3 = SWIG_AsVal_int(obj2, &val3);
13297 if (!SWIG_IsOK(ecode3)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13299 }
13300 arg3 = static_cast< int >(val3);
13301 }
13302 {
13303 PyThreadState* __tstate = wxPyBeginAllowThreads();
13304 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13305 wxPyEndAllowThreads(__tstate);
13306 if (PyErr_Occurred()) SWIG_fail;
13307 }
13308 {
13309 #if wxUSE_UNICODE
13310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13311 #else
13312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13313 #endif
13314 }
13315 {
13316 if (temp2)
13317 delete arg2;
13318 }
13319 return resultobj;
13320 fail:
13321 {
13322 if (temp2)
13323 delete arg2;
13324 }
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13330 PyObject *resultobj = 0;
13331 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13332 wxString result;
13333 void *argp1 = 0 ;
13334 int res1 = 0 ;
13335 PyObject *swig_obj[1] ;
13336
13337 if (!args) SWIG_fail;
13338 swig_obj[0] = args;
13339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13340 if (!SWIG_IsOK(res1)) {
13341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13342 }
13343 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 result = (arg1)->FindNext();
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 {
13351 #if wxUSE_UNICODE
13352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13353 #else
13354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13355 #endif
13356 }
13357 return resultobj;
13358 fail:
13359 return NULL;
13360 }
13361
13362
13363 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13364 PyObject *resultobj = 0;
13365 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13366 int res1 = 0 ;
13367 PyObject * obj0 = 0 ;
13368 char * kwnames[] = {
13369 (char *) "handler", NULL
13370 };
13371
13372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13373 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13374 if (!SWIG_IsOK(res1)) {
13375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13376 }
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 wxFileSystem::AddHandler(arg1);
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 resultobj = SWIG_Py_Void();
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj = 0;
13392 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13393 wxFileSystemHandler *result = 0 ;
13394 void *argp1 = 0 ;
13395 int res1 = 0 ;
13396 PyObject * obj0 = 0 ;
13397 char * kwnames[] = {
13398 (char *) "handler", NULL
13399 };
13400
13401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13403 if (!SWIG_IsOK(res1)) {
13404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13405 }
13406 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13407 {
13408 PyThreadState* __tstate = wxPyBeginAllowThreads();
13409 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13410 wxPyEndAllowThreads(__tstate);
13411 if (PyErr_Occurred()) SWIG_fail;
13412 }
13413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13414 return resultobj;
13415 fail:
13416 return NULL;
13417 }
13418
13419
13420 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13421 PyObject *resultobj = 0;
13422
13423 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 wxFileSystem::CleanUpHandlers();
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 resultobj = SWIG_Py_Void();
13431 return resultobj;
13432 fail:
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13438 PyObject *resultobj = 0;
13439 wxString *arg1 = 0 ;
13440 wxString result;
13441 bool temp1 = false ;
13442 PyObject * obj0 = 0 ;
13443 char * kwnames[] = {
13444 (char *) "filename", NULL
13445 };
13446
13447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13448 {
13449 arg1 = wxString_in_helper(obj0);
13450 if (arg1 == NULL) SWIG_fail;
13451 temp1 = true;
13452 }
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 {
13460 #if wxUSE_UNICODE
13461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13462 #else
13463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13464 #endif
13465 }
13466 {
13467 if (temp1)
13468 delete arg1;
13469 }
13470 return resultobj;
13471 fail:
13472 {
13473 if (temp1)
13474 delete arg1;
13475 }
13476 return NULL;
13477 }
13478
13479
13480 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13481 PyObject *resultobj = 0;
13482 wxString *arg1 = 0 ;
13483 wxString result;
13484 bool temp1 = false ;
13485 PyObject * obj0 = 0 ;
13486 char * kwnames[] = {
13487 (char *) "url", NULL
13488 };
13489
13490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13491 {
13492 arg1 = wxString_in_helper(obj0);
13493 if (arg1 == NULL) SWIG_fail;
13494 temp1 = true;
13495 }
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 {
13503 #if wxUSE_UNICODE
13504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13505 #else
13506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13507 #endif
13508 }
13509 {
13510 if (temp1)
13511 delete arg1;
13512 }
13513 return resultobj;
13514 fail:
13515 {
13516 if (temp1)
13517 delete arg1;
13518 }
13519 return NULL;
13520 }
13521
13522
13523 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13524 PyObject *obj;
13525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13526 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13527 return SWIG_Py_Void();
13528 }
13529
13530 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13531 return SWIG_Python_InitShadowInstance(args);
13532 }
13533
13534 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13535 PyObject *resultobj = 0;
13536 wxInternetFSHandler *result = 0 ;
13537
13538 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13542 wxPyEndAllowThreads(__tstate);
13543 if (PyErr_Occurred()) SWIG_fail;
13544 }
13545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj = 0;
13554 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13555 wxString *arg2 = 0 ;
13556 bool result;
13557 void *argp1 = 0 ;
13558 int res1 = 0 ;
13559 bool temp2 = false ;
13560 PyObject * obj0 = 0 ;
13561 PyObject * obj1 = 0 ;
13562 char * kwnames[] = {
13563 (char *) "self",(char *) "location", NULL
13564 };
13565
13566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13568 if (!SWIG_IsOK(res1)) {
13569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13570 }
13571 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13572 {
13573 arg2 = wxString_in_helper(obj1);
13574 if (arg2 == NULL) SWIG_fail;
13575 temp2 = true;
13576 }
13577 {
13578 PyThreadState* __tstate = wxPyBeginAllowThreads();
13579 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 {
13584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13585 }
13586 {
13587 if (temp2)
13588 delete arg2;
13589 }
13590 return resultobj;
13591 fail:
13592 {
13593 if (temp2)
13594 delete arg2;
13595 }
13596 return NULL;
13597 }
13598
13599
13600 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13601 PyObject *resultobj = 0;
13602 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13603 wxFileSystem *arg2 = 0 ;
13604 wxString *arg3 = 0 ;
13605 wxFSFile *result = 0 ;
13606 void *argp1 = 0 ;
13607 int res1 = 0 ;
13608 void *argp2 = 0 ;
13609 int res2 = 0 ;
13610 bool temp3 = false ;
13611 PyObject * obj0 = 0 ;
13612 PyObject * obj1 = 0 ;
13613 PyObject * obj2 = 0 ;
13614 char * kwnames[] = {
13615 (char *) "self",(char *) "fs",(char *) "location", NULL
13616 };
13617
13618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13620 if (!SWIG_IsOK(res1)) {
13621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13622 }
13623 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13625 if (!SWIG_IsOK(res2)) {
13626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13627 }
13628 if (!argp2) {
13629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13630 }
13631 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13632 {
13633 arg3 = wxString_in_helper(obj2);
13634 if (arg3 == NULL) SWIG_fail;
13635 temp3 = true;
13636 }
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 {
13644 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13645 }
13646 {
13647 if (temp3)
13648 delete arg3;
13649 }
13650 return resultobj;
13651 fail:
13652 {
13653 if (temp3)
13654 delete arg3;
13655 }
13656 return NULL;
13657 }
13658
13659
13660 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13661 PyObject *obj;
13662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13663 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13664 return SWIG_Py_Void();
13665 }
13666
13667 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13668 return SWIG_Python_InitShadowInstance(args);
13669 }
13670
13671 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13672 PyObject *resultobj = 0;
13673 wxZipFSHandler *result = 0 ;
13674
13675 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 result = (wxZipFSHandler *)new wxZipFSHandler();
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13683 return resultobj;
13684 fail:
13685 return NULL;
13686 }
13687
13688
13689 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj = 0;
13691 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13692 wxString *arg2 = 0 ;
13693 bool result;
13694 void *argp1 = 0 ;
13695 int res1 = 0 ;
13696 bool temp2 = false ;
13697 PyObject * obj0 = 0 ;
13698 PyObject * obj1 = 0 ;
13699 char * kwnames[] = {
13700 (char *) "self",(char *) "location", NULL
13701 };
13702
13703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13705 if (!SWIG_IsOK(res1)) {
13706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13707 }
13708 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13709 {
13710 arg2 = wxString_in_helper(obj1);
13711 if (arg2 == NULL) SWIG_fail;
13712 temp2 = true;
13713 }
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 {
13721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13722 }
13723 {
13724 if (temp2)
13725 delete arg2;
13726 }
13727 return resultobj;
13728 fail:
13729 {
13730 if (temp2)
13731 delete arg2;
13732 }
13733 return NULL;
13734 }
13735
13736
13737 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13738 PyObject *resultobj = 0;
13739 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13740 wxFileSystem *arg2 = 0 ;
13741 wxString *arg3 = 0 ;
13742 wxFSFile *result = 0 ;
13743 void *argp1 = 0 ;
13744 int res1 = 0 ;
13745 void *argp2 = 0 ;
13746 int res2 = 0 ;
13747 bool temp3 = false ;
13748 PyObject * obj0 = 0 ;
13749 PyObject * obj1 = 0 ;
13750 PyObject * obj2 = 0 ;
13751 char * kwnames[] = {
13752 (char *) "self",(char *) "fs",(char *) "location", NULL
13753 };
13754
13755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13757 if (!SWIG_IsOK(res1)) {
13758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13759 }
13760 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13762 if (!SWIG_IsOK(res2)) {
13763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13764 }
13765 if (!argp2) {
13766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13767 }
13768 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13769 {
13770 arg3 = wxString_in_helper(obj2);
13771 if (arg3 == NULL) SWIG_fail;
13772 temp3 = true;
13773 }
13774 {
13775 PyThreadState* __tstate = wxPyBeginAllowThreads();
13776 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13777 wxPyEndAllowThreads(__tstate);
13778 if (PyErr_Occurred()) SWIG_fail;
13779 }
13780 {
13781 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13782 }
13783 {
13784 if (temp3)
13785 delete arg3;
13786 }
13787 return resultobj;
13788 fail:
13789 {
13790 if (temp3)
13791 delete arg3;
13792 }
13793 return NULL;
13794 }
13795
13796
13797 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj = 0;
13799 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13800 wxString *arg2 = 0 ;
13801 int arg3 = (int) 0 ;
13802 wxString result;
13803 void *argp1 = 0 ;
13804 int res1 = 0 ;
13805 bool temp2 = false ;
13806 int val3 ;
13807 int ecode3 = 0 ;
13808 PyObject * obj0 = 0 ;
13809 PyObject * obj1 = 0 ;
13810 PyObject * obj2 = 0 ;
13811 char * kwnames[] = {
13812 (char *) "self",(char *) "spec",(char *) "flags", NULL
13813 };
13814
13815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13817 if (!SWIG_IsOK(res1)) {
13818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13819 }
13820 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13821 {
13822 arg2 = wxString_in_helper(obj1);
13823 if (arg2 == NULL) SWIG_fail;
13824 temp2 = true;
13825 }
13826 if (obj2) {
13827 ecode3 = SWIG_AsVal_int(obj2, &val3);
13828 if (!SWIG_IsOK(ecode3)) {
13829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13830 }
13831 arg3 = static_cast< int >(val3);
13832 }
13833 {
13834 PyThreadState* __tstate = wxPyBeginAllowThreads();
13835 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13836 wxPyEndAllowThreads(__tstate);
13837 if (PyErr_Occurred()) SWIG_fail;
13838 }
13839 {
13840 #if wxUSE_UNICODE
13841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13842 #else
13843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13844 #endif
13845 }
13846 {
13847 if (temp2)
13848 delete arg2;
13849 }
13850 return resultobj;
13851 fail:
13852 {
13853 if (temp2)
13854 delete arg2;
13855 }
13856 return NULL;
13857 }
13858
13859
13860 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13861 PyObject *resultobj = 0;
13862 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13863 wxString result;
13864 void *argp1 = 0 ;
13865 int res1 = 0 ;
13866 PyObject *swig_obj[1] ;
13867
13868 if (!args) SWIG_fail;
13869 swig_obj[0] = args;
13870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13871 if (!SWIG_IsOK(res1)) {
13872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13873 }
13874 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 result = (arg1)->FindNext();
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 {
13882 #if wxUSE_UNICODE
13883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13884 #else
13885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13886 #endif
13887 }
13888 return resultobj;
13889 fail:
13890 return NULL;
13891 }
13892
13893
13894 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13895 PyObject *obj;
13896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13897 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13898 return SWIG_Py_Void();
13899 }
13900
13901 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13902 return SWIG_Python_InitShadowInstance(args);
13903 }
13904
13905 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13906 PyObject *resultobj = 0;
13907 wxString *arg1 = 0 ;
13908 wxImage *arg2 = 0 ;
13909 long arg3 ;
13910 bool temp1 = false ;
13911 void *argp2 = 0 ;
13912 int res2 = 0 ;
13913 long val3 ;
13914 int ecode3 = 0 ;
13915 PyObject * obj0 = 0 ;
13916 PyObject * obj1 = 0 ;
13917 PyObject * obj2 = 0 ;
13918 char * kwnames[] = {
13919 (char *) "filename",(char *) "image",(char *) "type", NULL
13920 };
13921
13922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13923 {
13924 arg1 = wxString_in_helper(obj0);
13925 if (arg1 == NULL) SWIG_fail;
13926 temp1 = true;
13927 }
13928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13929 if (!SWIG_IsOK(res2)) {
13930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13931 }
13932 if (!argp2) {
13933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13934 }
13935 arg2 = reinterpret_cast< wxImage * >(argp2);
13936 ecode3 = SWIG_AsVal_long(obj2, &val3);
13937 if (!SWIG_IsOK(ecode3)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13939 }
13940 arg3 = static_cast< long >(val3);
13941 {
13942 PyThreadState* __tstate = wxPyBeginAllowThreads();
13943 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13944 wxPyEndAllowThreads(__tstate);
13945 if (PyErr_Occurred()) SWIG_fail;
13946 }
13947 resultobj = SWIG_Py_Void();
13948 {
13949 if (temp1)
13950 delete arg1;
13951 }
13952 return resultobj;
13953 fail:
13954 {
13955 if (temp1)
13956 delete arg1;
13957 }
13958 return NULL;
13959 }
13960
13961
13962 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13963 PyObject *resultobj = 0;
13964 wxString *arg1 = 0 ;
13965 wxBitmap *arg2 = 0 ;
13966 long arg3 ;
13967 bool temp1 = false ;
13968 void *argp2 = 0 ;
13969 int res2 = 0 ;
13970 long val3 ;
13971 int ecode3 = 0 ;
13972 PyObject * obj0 = 0 ;
13973 PyObject * obj1 = 0 ;
13974 PyObject * obj2 = 0 ;
13975 char * kwnames[] = {
13976 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13977 };
13978
13979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13980 {
13981 arg1 = wxString_in_helper(obj0);
13982 if (arg1 == NULL) SWIG_fail;
13983 temp1 = true;
13984 }
13985 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13986 if (!SWIG_IsOK(res2)) {
13987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13988 }
13989 if (!argp2) {
13990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13991 }
13992 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13993 ecode3 = SWIG_AsVal_long(obj2, &val3);
13994 if (!SWIG_IsOK(ecode3)) {
13995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13996 }
13997 arg3 = static_cast< long >(val3);
13998 {
13999 PyThreadState* __tstate = wxPyBeginAllowThreads();
14000 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14001 wxPyEndAllowThreads(__tstate);
14002 if (PyErr_Occurred()) SWIG_fail;
14003 }
14004 resultobj = SWIG_Py_Void();
14005 {
14006 if (temp1)
14007 delete arg1;
14008 }
14009 return resultobj;
14010 fail:
14011 {
14012 if (temp1)
14013 delete arg1;
14014 }
14015 return NULL;
14016 }
14017
14018
14019 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14020 PyObject *resultobj = 0;
14021 wxString *arg1 = 0 ;
14022 PyObject *arg2 = (PyObject *) 0 ;
14023 bool temp1 = false ;
14024 PyObject * obj0 = 0 ;
14025 PyObject * obj1 = 0 ;
14026 char * kwnames[] = {
14027 (char *) "filename",(char *) "data", NULL
14028 };
14029
14030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14031 {
14032 arg1 = wxString_in_helper(obj0);
14033 if (arg1 == NULL) SWIG_fail;
14034 temp1 = true;
14035 }
14036 arg2 = obj1;
14037 {
14038 PyThreadState* __tstate = wxPyBeginAllowThreads();
14039 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 resultobj = SWIG_Py_Void();
14044 {
14045 if (temp1)
14046 delete arg1;
14047 }
14048 return resultobj;
14049 fail:
14050 {
14051 if (temp1)
14052 delete arg1;
14053 }
14054 return NULL;
14055 }
14056
14057
14058 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14059 PyObject *resultobj = 0;
14060 wxMemoryFSHandler *result = 0 ;
14061
14062 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj = 0;
14078 wxString *arg1 = 0 ;
14079 bool temp1 = false ;
14080 PyObject * obj0 = 0 ;
14081 char * kwnames[] = {
14082 (char *) "filename", NULL
14083 };
14084
14085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14086 {
14087 arg1 = wxString_in_helper(obj0);
14088 if (arg1 == NULL) SWIG_fail;
14089 temp1 = true;
14090 }
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 resultobj = SWIG_Py_Void();
14098 {
14099 if (temp1)
14100 delete arg1;
14101 }
14102 return resultobj;
14103 fail:
14104 {
14105 if (temp1)
14106 delete arg1;
14107 }
14108 return NULL;
14109 }
14110
14111
14112 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj = 0;
14114 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14115 wxString *arg2 = 0 ;
14116 bool result;
14117 void *argp1 = 0 ;
14118 int res1 = 0 ;
14119 bool temp2 = false ;
14120 PyObject * obj0 = 0 ;
14121 PyObject * obj1 = 0 ;
14122 char * kwnames[] = {
14123 (char *) "self",(char *) "location", NULL
14124 };
14125
14126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14128 if (!SWIG_IsOK(res1)) {
14129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14130 }
14131 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14132 {
14133 arg2 = wxString_in_helper(obj1);
14134 if (arg2 == NULL) SWIG_fail;
14135 temp2 = true;
14136 }
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14145 }
14146 {
14147 if (temp2)
14148 delete arg2;
14149 }
14150 return resultobj;
14151 fail:
14152 {
14153 if (temp2)
14154 delete arg2;
14155 }
14156 return NULL;
14157 }
14158
14159
14160 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14161 PyObject *resultobj = 0;
14162 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14163 wxFileSystem *arg2 = 0 ;
14164 wxString *arg3 = 0 ;
14165 wxFSFile *result = 0 ;
14166 void *argp1 = 0 ;
14167 int res1 = 0 ;
14168 void *argp2 = 0 ;
14169 int res2 = 0 ;
14170 bool temp3 = false ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 char * kwnames[] = {
14175 (char *) "self",(char *) "fs",(char *) "location", NULL
14176 };
14177
14178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14180 if (!SWIG_IsOK(res1)) {
14181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14182 }
14183 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14185 if (!SWIG_IsOK(res2)) {
14186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14187 }
14188 if (!argp2) {
14189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14190 }
14191 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14192 {
14193 arg3 = wxString_in_helper(obj2);
14194 if (arg3 == NULL) SWIG_fail;
14195 temp3 = true;
14196 }
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 {
14204 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14205 }
14206 {
14207 if (temp3)
14208 delete arg3;
14209 }
14210 return resultobj;
14211 fail:
14212 {
14213 if (temp3)
14214 delete arg3;
14215 }
14216 return NULL;
14217 }
14218
14219
14220 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj = 0;
14222 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14223 wxString *arg2 = 0 ;
14224 int arg3 = (int) 0 ;
14225 wxString result;
14226 void *argp1 = 0 ;
14227 int res1 = 0 ;
14228 bool temp2 = false ;
14229 int val3 ;
14230 int ecode3 = 0 ;
14231 PyObject * obj0 = 0 ;
14232 PyObject * obj1 = 0 ;
14233 PyObject * obj2 = 0 ;
14234 char * kwnames[] = {
14235 (char *) "self",(char *) "spec",(char *) "flags", NULL
14236 };
14237
14238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14240 if (!SWIG_IsOK(res1)) {
14241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14242 }
14243 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14244 {
14245 arg2 = wxString_in_helper(obj1);
14246 if (arg2 == NULL) SWIG_fail;
14247 temp2 = true;
14248 }
14249 if (obj2) {
14250 ecode3 = SWIG_AsVal_int(obj2, &val3);
14251 if (!SWIG_IsOK(ecode3)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14253 }
14254 arg3 = static_cast< int >(val3);
14255 }
14256 {
14257 PyThreadState* __tstate = wxPyBeginAllowThreads();
14258 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 {
14263 #if wxUSE_UNICODE
14264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14265 #else
14266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14267 #endif
14268 }
14269 {
14270 if (temp2)
14271 delete arg2;
14272 }
14273 return resultobj;
14274 fail:
14275 {
14276 if (temp2)
14277 delete arg2;
14278 }
14279 return NULL;
14280 }
14281
14282
14283 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14284 PyObject *resultobj = 0;
14285 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14286 wxString result;
14287 void *argp1 = 0 ;
14288 int res1 = 0 ;
14289 PyObject *swig_obj[1] ;
14290
14291 if (!args) SWIG_fail;
14292 swig_obj[0] = args;
14293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14294 if (!SWIG_IsOK(res1)) {
14295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14296 }
14297 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14298 {
14299 PyThreadState* __tstate = wxPyBeginAllowThreads();
14300 result = (arg1)->FindNext();
14301 wxPyEndAllowThreads(__tstate);
14302 if (PyErr_Occurred()) SWIG_fail;
14303 }
14304 {
14305 #if wxUSE_UNICODE
14306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14307 #else
14308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14309 #endif
14310 }
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14318 PyObject *obj;
14319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14320 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14321 return SWIG_Py_Void();
14322 }
14323
14324 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14325 return SWIG_Python_InitShadowInstance(args);
14326 }
14327
14328 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14329 PyObject *resultobj = 0;
14330 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14331 wxString result;
14332 void *argp1 = 0 ;
14333 int res1 = 0 ;
14334 PyObject *swig_obj[1] ;
14335
14336 if (!args) SWIG_fail;
14337 swig_obj[0] = args;
14338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14339 if (!SWIG_IsOK(res1)) {
14340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14341 }
14342 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14343 {
14344 PyThreadState* __tstate = wxPyBeginAllowThreads();
14345 result = (arg1)->GetName();
14346 wxPyEndAllowThreads(__tstate);
14347 if (PyErr_Occurred()) SWIG_fail;
14348 }
14349 {
14350 #if wxUSE_UNICODE
14351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14352 #else
14353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14354 #endif
14355 }
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14363 PyObject *resultobj = 0;
14364 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14365 wxString result;
14366 void *argp1 = 0 ;
14367 int res1 = 0 ;
14368 PyObject *swig_obj[1] ;
14369
14370 if (!args) SWIG_fail;
14371 swig_obj[0] = args;
14372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14373 if (!SWIG_IsOK(res1)) {
14374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14375 }
14376 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (arg1)->GetExtension();
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 {
14384 #if wxUSE_UNICODE
14385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14386 #else
14387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14388 #endif
14389 }
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14397 PyObject *resultobj = 0;
14398 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14399 long result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 PyObject *swig_obj[1] ;
14403
14404 if (!args) SWIG_fail;
14405 swig_obj[0] = args;
14406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14407 if (!SWIG_IsOK(res1)) {
14408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14409 }
14410 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (long)(arg1)->GetType();
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 resultobj = SWIG_From_long(static_cast< long >(result));
14418 return resultobj;
14419 fail:
14420 return NULL;
14421 }
14422
14423
14424 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14425 PyObject *resultobj = 0;
14426 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14427 wxString result;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 PyObject *swig_obj[1] ;
14431
14432 if (!args) SWIG_fail;
14433 swig_obj[0] = args;
14434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14435 if (!SWIG_IsOK(res1)) {
14436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14437 }
14438 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 result = (arg1)->GetMimeType();
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 {
14446 #if wxUSE_UNICODE
14447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14448 #else
14449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14450 #endif
14451 }
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14461 wxString *arg2 = 0 ;
14462 bool result;
14463 void *argp1 = 0 ;
14464 int res1 = 0 ;
14465 bool temp2 = false ;
14466 PyObject * obj0 = 0 ;
14467 PyObject * obj1 = 0 ;
14468 char * kwnames[] = {
14469 (char *) "self",(char *) "name", NULL
14470 };
14471
14472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14474 if (!SWIG_IsOK(res1)) {
14475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14476 }
14477 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14478 {
14479 arg2 = wxString_in_helper(obj1);
14480 if (arg2 == NULL) SWIG_fail;
14481 temp2 = true;
14482 }
14483 {
14484 PyThreadState* __tstate = wxPyBeginAllowThreads();
14485 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14486 wxPyEndAllowThreads(__tstate);
14487 if (PyErr_Occurred()) SWIG_fail;
14488 }
14489 {
14490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14491 }
14492 {
14493 if (temp2)
14494 delete arg2;
14495 }
14496 return resultobj;
14497 fail:
14498 {
14499 if (temp2)
14500 delete arg2;
14501 }
14502 return NULL;
14503 }
14504
14505
14506 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14507 PyObject *resultobj = 0;
14508 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14509 wxInputStream *arg2 = 0 ;
14510 bool result;
14511 void *argp1 = 0 ;
14512 int res1 = 0 ;
14513 wxPyInputStream *temp2 ;
14514 bool created2 ;
14515 PyObject * obj0 = 0 ;
14516 PyObject * obj1 = 0 ;
14517 char * kwnames[] = {
14518 (char *) "self",(char *) "stream", NULL
14519 };
14520
14521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14523 if (!SWIG_IsOK(res1)) {
14524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14525 }
14526 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14527 {
14528 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14529 arg2 = temp2->m_wxis;
14530 created2 = false;
14531 } else {
14532 PyErr_Clear(); // clear the failure of the wxPyConvert above
14533 arg2 = wxPyCBInputStream_create(obj1, false);
14534 if (arg2 == NULL) {
14535 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14536 SWIG_fail;
14537 }
14538 created2 = true;
14539 }
14540 }
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 result = (bool)(arg1)->CanRead(*arg2);
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 {
14548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14549 }
14550 {
14551 if (created2) delete arg2;
14552 }
14553 return resultobj;
14554 fail:
14555 {
14556 if (created2) delete arg2;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14565 wxString *arg2 = 0 ;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 bool temp2 = false ;
14569 PyObject * obj0 = 0 ;
14570 PyObject * obj1 = 0 ;
14571 char * kwnames[] = {
14572 (char *) "self",(char *) "name", NULL
14573 };
14574
14575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14577 if (!SWIG_IsOK(res1)) {
14578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14579 }
14580 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14581 {
14582 arg2 = wxString_in_helper(obj1);
14583 if (arg2 == NULL) SWIG_fail;
14584 temp2 = true;
14585 }
14586 {
14587 PyThreadState* __tstate = wxPyBeginAllowThreads();
14588 (arg1)->SetName((wxString const &)*arg2);
14589 wxPyEndAllowThreads(__tstate);
14590 if (PyErr_Occurred()) SWIG_fail;
14591 }
14592 resultobj = SWIG_Py_Void();
14593 {
14594 if (temp2)
14595 delete arg2;
14596 }
14597 return resultobj;
14598 fail:
14599 {
14600 if (temp2)
14601 delete arg2;
14602 }
14603 return NULL;
14604 }
14605
14606
14607 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj = 0;
14609 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14610 wxString *arg2 = 0 ;
14611 void *argp1 = 0 ;
14612 int res1 = 0 ;
14613 bool temp2 = false ;
14614 PyObject * obj0 = 0 ;
14615 PyObject * obj1 = 0 ;
14616 char * kwnames[] = {
14617 (char *) "self",(char *) "extension", NULL
14618 };
14619
14620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14622 if (!SWIG_IsOK(res1)) {
14623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14624 }
14625 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14626 {
14627 arg2 = wxString_in_helper(obj1);
14628 if (arg2 == NULL) SWIG_fail;
14629 temp2 = true;
14630 }
14631 {
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 (arg1)->SetExtension((wxString const &)*arg2);
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 resultobj = SWIG_Py_Void();
14638 {
14639 if (temp2)
14640 delete arg2;
14641 }
14642 return resultobj;
14643 fail:
14644 {
14645 if (temp2)
14646 delete arg2;
14647 }
14648 return NULL;
14649 }
14650
14651
14652 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14653 PyObject *resultobj = 0;
14654 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14655 long arg2 ;
14656 void *argp1 = 0 ;
14657 int res1 = 0 ;
14658 long val2 ;
14659 int ecode2 = 0 ;
14660 PyObject * obj0 = 0 ;
14661 PyObject * obj1 = 0 ;
14662 char * kwnames[] = {
14663 (char *) "self",(char *) "type", NULL
14664 };
14665
14666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14668 if (!SWIG_IsOK(res1)) {
14669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14670 }
14671 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14672 ecode2 = SWIG_AsVal_long(obj1, &val2);
14673 if (!SWIG_IsOK(ecode2)) {
14674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14675 }
14676 arg2 = static_cast< long >(val2);
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 (arg1)->SetType(arg2);
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = SWIG_Py_Void();
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj = 0;
14692 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14693 wxString *arg2 = 0 ;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 bool temp2 = false ;
14697 PyObject * obj0 = 0 ;
14698 PyObject * obj1 = 0 ;
14699 char * kwnames[] = {
14700 (char *) "self",(char *) "mimetype", NULL
14701 };
14702
14703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14707 }
14708 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14709 {
14710 arg2 = wxString_in_helper(obj1);
14711 if (arg2 == NULL) SWIG_fail;
14712 temp2 = true;
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 (arg1)->SetMimeType((wxString const &)*arg2);
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 resultobj = SWIG_Py_Void();
14721 {
14722 if (temp2)
14723 delete arg2;
14724 }
14725 return resultobj;
14726 fail:
14727 {
14728 if (temp2)
14729 delete arg2;
14730 }
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14736 PyObject *obj;
14737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14738 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14739 return SWIG_Py_Void();
14740 }
14741
14742 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14743 PyObject *resultobj = 0;
14744 wxPyImageHandler *result = 0 ;
14745
14746 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (wxPyImageHandler *)new wxPyImageHandler();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14761 PyObject *resultobj = 0;
14762 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14763 PyObject *arg2 = (PyObject *) 0 ;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 PyObject * obj0 = 0 ;
14767 PyObject * obj1 = 0 ;
14768 char * kwnames[] = {
14769 (char *) "self",(char *) "self", NULL
14770 };
14771
14772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14774 if (!SWIG_IsOK(res1)) {
14775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14776 }
14777 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14778 arg2 = obj1;
14779 {
14780 PyThreadState* __tstate = wxPyBeginAllowThreads();
14781 (arg1)->_SetSelf(arg2);
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 resultobj = SWIG_Py_Void();
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14793 PyObject *obj;
14794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14795 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14796 return SWIG_Py_Void();
14797 }
14798
14799 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14800 return SWIG_Python_InitShadowInstance(args);
14801 }
14802
14803 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14804 PyObject *resultobj = 0;
14805 wxImageHistogram *result = 0 ;
14806
14807 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 result = (wxImageHistogram *)new wxImageHistogram();
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14822 PyObject *resultobj = 0;
14823 byte arg1 ;
14824 byte arg2 ;
14825 byte arg3 ;
14826 unsigned long result;
14827 unsigned char val1 ;
14828 int ecode1 = 0 ;
14829 unsigned char val2 ;
14830 int ecode2 = 0 ;
14831 unsigned char val3 ;
14832 int ecode3 = 0 ;
14833 PyObject * obj0 = 0 ;
14834 PyObject * obj1 = 0 ;
14835 PyObject * obj2 = 0 ;
14836 char * kwnames[] = {
14837 (char *) "r",(char *) "g",(char *) "b", NULL
14838 };
14839
14840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14841 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14842 if (!SWIG_IsOK(ecode1)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14844 }
14845 arg1 = static_cast< byte >(val1);
14846 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14847 if (!SWIG_IsOK(ecode2)) {
14848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14849 }
14850 arg2 = static_cast< byte >(val2);
14851 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14852 if (!SWIG_IsOK(ecode3)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14854 }
14855 arg3 = static_cast< byte >(val3);
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj = 0;
14871 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14872 byte *arg2 = (byte *) 0 ;
14873 byte *arg3 = (byte *) 0 ;
14874 byte *arg4 = (byte *) 0 ;
14875 byte arg5 = (byte) 1 ;
14876 byte arg6 = (byte) 0 ;
14877 byte arg7 = (byte) 0 ;
14878 bool result;
14879 void *argp1 = 0 ;
14880 int res1 = 0 ;
14881 byte temp2 ;
14882 int res2 = SWIG_TMPOBJ ;
14883 byte temp3 ;
14884 int res3 = SWIG_TMPOBJ ;
14885 byte temp4 ;
14886 int res4 = SWIG_TMPOBJ ;
14887 unsigned char val5 ;
14888 int ecode5 = 0 ;
14889 unsigned char val6 ;
14890 int ecode6 = 0 ;
14891 unsigned char val7 ;
14892 int ecode7 = 0 ;
14893 PyObject * obj0 = 0 ;
14894 PyObject * obj1 = 0 ;
14895 PyObject * obj2 = 0 ;
14896 PyObject * obj3 = 0 ;
14897 char * kwnames[] = {
14898 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14899 };
14900
14901 arg2 = &temp2;
14902 arg3 = &temp3;
14903 arg4 = &temp4;
14904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14906 if (!SWIG_IsOK(res1)) {
14907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14908 }
14909 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14910 if (obj1) {
14911 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14912 if (!SWIG_IsOK(ecode5)) {
14913 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14914 }
14915 arg5 = static_cast< byte >(val5);
14916 }
14917 if (obj2) {
14918 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14919 if (!SWIG_IsOK(ecode6)) {
14920 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14921 }
14922 arg6 = static_cast< byte >(val6);
14923 }
14924 if (obj3) {
14925 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14926 if (!SWIG_IsOK(ecode7)) {
14927 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14928 }
14929 arg7 = static_cast< byte >(val7);
14930 }
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14934 wxPyEndAllowThreads(__tstate);
14935 if (PyErr_Occurred()) SWIG_fail;
14936 }
14937 {
14938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14939 }
14940 if (SWIG_IsTmpObj(res2)) {
14941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14942 } else {
14943 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14945 }
14946 if (SWIG_IsTmpObj(res3)) {
14947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14948 } else {
14949 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14951 }
14952 if (SWIG_IsTmpObj(res4)) {
14953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14954 } else {
14955 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14956 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14957 }
14958 return resultobj;
14959 fail:
14960 return NULL;
14961 }
14962
14963
14964 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14965 PyObject *resultobj = 0;
14966 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14967 unsigned long arg2 ;
14968 unsigned long result;
14969 void *argp1 = 0 ;
14970 int res1 = 0 ;
14971 unsigned long val2 ;
14972 int ecode2 = 0 ;
14973 PyObject * obj0 = 0 ;
14974 PyObject * obj1 = 0 ;
14975 char * kwnames[] = {
14976 (char *) "self",(char *) "key", NULL
14977 };
14978
14979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14981 if (!SWIG_IsOK(res1)) {
14982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14983 }
14984 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14985 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14986 if (!SWIG_IsOK(ecode2)) {
14987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14988 }
14989 arg2 = static_cast< unsigned long >(val2);
14990 {
14991 PyThreadState* __tstate = wxPyBeginAllowThreads();
14992 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14997 return resultobj;
14998 fail:
14999 return NULL;
15000 }
15001
15002
15003 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15004 PyObject *resultobj = 0;
15005 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15006 byte arg2 ;
15007 byte arg3 ;
15008 byte arg4 ;
15009 unsigned long result;
15010 void *argp1 = 0 ;
15011 int res1 = 0 ;
15012 unsigned char val2 ;
15013 int ecode2 = 0 ;
15014 unsigned char val3 ;
15015 int ecode3 = 0 ;
15016 unsigned char val4 ;
15017 int ecode4 = 0 ;
15018 PyObject * obj0 = 0 ;
15019 PyObject * obj1 = 0 ;
15020 PyObject * obj2 = 0 ;
15021 PyObject * obj3 = 0 ;
15022 char * kwnames[] = {
15023 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15024 };
15025
15026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15028 if (!SWIG_IsOK(res1)) {
15029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15030 }
15031 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15032 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15033 if (!SWIG_IsOK(ecode2)) {
15034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15035 }
15036 arg2 = static_cast< byte >(val2);
15037 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15038 if (!SWIG_IsOK(ecode3)) {
15039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15040 }
15041 arg3 = static_cast< byte >(val3);
15042 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15043 if (!SWIG_IsOK(ecode4)) {
15044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15045 }
15046 arg4 = static_cast< byte >(val4);
15047 {
15048 PyThreadState* __tstate = wxPyBeginAllowThreads();
15049 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15054 return resultobj;
15055 fail:
15056 return NULL;
15057 }
15058
15059
15060 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15061 PyObject *resultobj = 0;
15062 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15063 wxColour *arg2 = 0 ;
15064 unsigned long result;
15065 void *argp1 = 0 ;
15066 int res1 = 0 ;
15067 wxColour temp2 ;
15068 PyObject * obj0 = 0 ;
15069 PyObject * obj1 = 0 ;
15070 char * kwnames[] = {
15071 (char *) "self",(char *) "colour", NULL
15072 };
15073
15074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15076 if (!SWIG_IsOK(res1)) {
15077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15078 }
15079 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15080 {
15081 arg2 = &temp2;
15082 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15083 }
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15091 return resultobj;
15092 fail:
15093 return NULL;
15094 }
15095
15096
15097 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15098 PyObject *obj;
15099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15100 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15101 return SWIG_Py_Void();
15102 }
15103
15104 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15105 return SWIG_Python_InitShadowInstance(args);
15106 }
15107
15108 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj = 0;
15110 byte arg1 = (byte) 0 ;
15111 byte arg2 = (byte) 0 ;
15112 byte arg3 = (byte) 0 ;
15113 wxImage_RGBValue *result = 0 ;
15114 unsigned char val1 ;
15115 int ecode1 = 0 ;
15116 unsigned char val2 ;
15117 int ecode2 = 0 ;
15118 unsigned char val3 ;
15119 int ecode3 = 0 ;
15120 PyObject * obj0 = 0 ;
15121 PyObject * obj1 = 0 ;
15122 PyObject * obj2 = 0 ;
15123 char * kwnames[] = {
15124 (char *) "r",(char *) "g",(char *) "b", NULL
15125 };
15126
15127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15128 if (obj0) {
15129 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15130 if (!SWIG_IsOK(ecode1)) {
15131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15132 }
15133 arg1 = static_cast< byte >(val1);
15134 }
15135 if (obj1) {
15136 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15137 if (!SWIG_IsOK(ecode2)) {
15138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15139 }
15140 arg2 = static_cast< byte >(val2);
15141 }
15142 if (obj2) {
15143 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15144 if (!SWIG_IsOK(ecode3)) {
15145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15146 }
15147 arg3 = static_cast< byte >(val3);
15148 }
15149 {
15150 PyThreadState* __tstate = wxPyBeginAllowThreads();
15151 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15163 PyObject *resultobj = 0;
15164 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15165 byte arg2 ;
15166 void *argp1 = 0 ;
15167 int res1 = 0 ;
15168 unsigned char val2 ;
15169 int ecode2 = 0 ;
15170 PyObject *swig_obj[2] ;
15171
15172 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15174 if (!SWIG_IsOK(res1)) {
15175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15176 }
15177 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15178 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15179 if (!SWIG_IsOK(ecode2)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15181 }
15182 arg2 = static_cast< byte >(val2);
15183 if (arg1) (arg1)->red = arg2;
15184
15185 resultobj = SWIG_Py_Void();
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15193 PyObject *resultobj = 0;
15194 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15195 byte result;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 PyObject *swig_obj[1] ;
15199
15200 if (!args) SWIG_fail;
15201 swig_obj[0] = args;
15202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15205 }
15206 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15207 result = (byte) ((arg1)->red);
15208 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15216 PyObject *resultobj = 0;
15217 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15218 byte arg2 ;
15219 void *argp1 = 0 ;
15220 int res1 = 0 ;
15221 unsigned char val2 ;
15222 int ecode2 = 0 ;
15223 PyObject *swig_obj[2] ;
15224
15225 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15229 }
15230 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15231 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15232 if (!SWIG_IsOK(ecode2)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15234 }
15235 arg2 = static_cast< byte >(val2);
15236 if (arg1) (arg1)->green = arg2;
15237
15238 resultobj = SWIG_Py_Void();
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15246 PyObject *resultobj = 0;
15247 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15248 byte result;
15249 void *argp1 = 0 ;
15250 int res1 = 0 ;
15251 PyObject *swig_obj[1] ;
15252
15253 if (!args) SWIG_fail;
15254 swig_obj[0] = args;
15255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15256 if (!SWIG_IsOK(res1)) {
15257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15258 }
15259 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15260 result = (byte) ((arg1)->green);
15261 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15269 PyObject *resultobj = 0;
15270 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15271 byte arg2 ;
15272 void *argp1 = 0 ;
15273 int res1 = 0 ;
15274 unsigned char val2 ;
15275 int ecode2 = 0 ;
15276 PyObject *swig_obj[2] ;
15277
15278 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15280 if (!SWIG_IsOK(res1)) {
15281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15282 }
15283 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15284 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15285 if (!SWIG_IsOK(ecode2)) {
15286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15287 }
15288 arg2 = static_cast< byte >(val2);
15289 if (arg1) (arg1)->blue = arg2;
15290
15291 resultobj = SWIG_Py_Void();
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15299 PyObject *resultobj = 0;
15300 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15301 byte result;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject *swig_obj[1] ;
15305
15306 if (!args) SWIG_fail;
15307 swig_obj[0] = args;
15308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15309 if (!SWIG_IsOK(res1)) {
15310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15311 }
15312 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15313 result = (byte) ((arg1)->blue);
15314 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15322 PyObject *obj;
15323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15324 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15325 return SWIG_Py_Void();
15326 }
15327
15328 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15329 return SWIG_Python_InitShadowInstance(args);
15330 }
15331
15332 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15333 PyObject *resultobj = 0;
15334 double arg1 = (double) 0.0 ;
15335 double arg2 = (double) 0.0 ;
15336 double arg3 = (double) 0.0 ;
15337 wxImage_HSVValue *result = 0 ;
15338 double val1 ;
15339 int ecode1 = 0 ;
15340 double val2 ;
15341 int ecode2 = 0 ;
15342 double val3 ;
15343 int ecode3 = 0 ;
15344 PyObject * obj0 = 0 ;
15345 PyObject * obj1 = 0 ;
15346 PyObject * obj2 = 0 ;
15347 char * kwnames[] = {
15348 (char *) "h",(char *) "s",(char *) "v", NULL
15349 };
15350
15351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15352 if (obj0) {
15353 ecode1 = SWIG_AsVal_double(obj0, &val1);
15354 if (!SWIG_IsOK(ecode1)) {
15355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15356 }
15357 arg1 = static_cast< double >(val1);
15358 }
15359 if (obj1) {
15360 ecode2 = SWIG_AsVal_double(obj1, &val2);
15361 if (!SWIG_IsOK(ecode2)) {
15362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15363 }
15364 arg2 = static_cast< double >(val2);
15365 }
15366 if (obj2) {
15367 ecode3 = SWIG_AsVal_double(obj2, &val3);
15368 if (!SWIG_IsOK(ecode3)) {
15369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15370 }
15371 arg3 = static_cast< double >(val3);
15372 }
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15387 PyObject *resultobj = 0;
15388 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15389 double arg2 ;
15390 void *argp1 = 0 ;
15391 int res1 = 0 ;
15392 double val2 ;
15393 int ecode2 = 0 ;
15394 PyObject *swig_obj[2] ;
15395
15396 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15398 if (!SWIG_IsOK(res1)) {
15399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15400 }
15401 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15402 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15403 if (!SWIG_IsOK(ecode2)) {
15404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15405 }
15406 arg2 = static_cast< double >(val2);
15407 if (arg1) (arg1)->hue = arg2;
15408
15409 resultobj = SWIG_Py_Void();
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15417 PyObject *resultobj = 0;
15418 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15419 double result;
15420 void *argp1 = 0 ;
15421 int res1 = 0 ;
15422 PyObject *swig_obj[1] ;
15423
15424 if (!args) SWIG_fail;
15425 swig_obj[0] = args;
15426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15429 }
15430 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15431 result = (double) ((arg1)->hue);
15432 resultobj = SWIG_From_double(static_cast< double >(result));
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440 PyObject *resultobj = 0;
15441 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15442 double arg2 ;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 double val2 ;
15446 int ecode2 = 0 ;
15447 PyObject *swig_obj[2] ;
15448
15449 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15451 if (!SWIG_IsOK(res1)) {
15452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15453 }
15454 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15455 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15456 if (!SWIG_IsOK(ecode2)) {
15457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15458 }
15459 arg2 = static_cast< double >(val2);
15460 if (arg1) (arg1)->saturation = arg2;
15461
15462 resultobj = SWIG_Py_Void();
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15470 PyObject *resultobj = 0;
15471 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15472 double result;
15473 void *argp1 = 0 ;
15474 int res1 = 0 ;
15475 PyObject *swig_obj[1] ;
15476
15477 if (!args) SWIG_fail;
15478 swig_obj[0] = args;
15479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15480 if (!SWIG_IsOK(res1)) {
15481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15482 }
15483 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15484 result = (double) ((arg1)->saturation);
15485 resultobj = SWIG_From_double(static_cast< double >(result));
15486 return resultobj;
15487 fail:
15488 return NULL;
15489 }
15490
15491
15492 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15493 PyObject *resultobj = 0;
15494 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15495 double arg2 ;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 double val2 ;
15499 int ecode2 = 0 ;
15500 PyObject *swig_obj[2] ;
15501
15502 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15504 if (!SWIG_IsOK(res1)) {
15505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15506 }
15507 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15508 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15509 if (!SWIG_IsOK(ecode2)) {
15510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15511 }
15512 arg2 = static_cast< double >(val2);
15513 if (arg1) (arg1)->value = arg2;
15514
15515 resultobj = SWIG_Py_Void();
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15523 PyObject *resultobj = 0;
15524 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15525 double result;
15526 void *argp1 = 0 ;
15527 int res1 = 0 ;
15528 PyObject *swig_obj[1] ;
15529
15530 if (!args) SWIG_fail;
15531 swig_obj[0] = args;
15532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15535 }
15536 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15537 result = (double) ((arg1)->value);
15538 resultobj = SWIG_From_double(static_cast< double >(result));
15539 return resultobj;
15540 fail:
15541 return NULL;
15542 }
15543
15544
15545 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15546 PyObject *obj;
15547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15548 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15549 return SWIG_Py_Void();
15550 }
15551
15552 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15553 return SWIG_Python_InitShadowInstance(args);
15554 }
15555
15556 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15557 PyObject *resultobj = 0;
15558 wxString *arg1 = 0 ;
15559 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15560 int arg3 = (int) -1 ;
15561 wxImage *result = 0 ;
15562 bool temp1 = false ;
15563 long val2 ;
15564 int ecode2 = 0 ;
15565 int val3 ;
15566 int ecode3 = 0 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 PyObject * obj2 = 0 ;
15570 char * kwnames[] = {
15571 (char *) "name",(char *) "type",(char *) "index", NULL
15572 };
15573
15574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15575 {
15576 arg1 = wxString_in_helper(obj0);
15577 if (arg1 == NULL) SWIG_fail;
15578 temp1 = true;
15579 }
15580 if (obj1) {
15581 ecode2 = SWIG_AsVal_long(obj1, &val2);
15582 if (!SWIG_IsOK(ecode2)) {
15583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15584 }
15585 arg2 = static_cast< long >(val2);
15586 }
15587 if (obj2) {
15588 ecode3 = SWIG_AsVal_int(obj2, &val3);
15589 if (!SWIG_IsOK(ecode3)) {
15590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15591 }
15592 arg3 = static_cast< int >(val3);
15593 }
15594 {
15595 PyThreadState* __tstate = wxPyBeginAllowThreads();
15596 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15597 wxPyEndAllowThreads(__tstate);
15598 if (PyErr_Occurred()) SWIG_fail;
15599 }
15600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15601 {
15602 if (temp1)
15603 delete arg1;
15604 }
15605 return resultobj;
15606 fail:
15607 {
15608 if (temp1)
15609 delete arg1;
15610 }
15611 return NULL;
15612 }
15613
15614
15615 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15616 PyObject *resultobj = 0;
15617 wxImage *arg1 = (wxImage *) 0 ;
15618 void *argp1 = 0 ;
15619 int res1 = 0 ;
15620 PyObject *swig_obj[1] ;
15621
15622 if (!args) SWIG_fail;
15623 swig_obj[0] = args;
15624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15625 if (!SWIG_IsOK(res1)) {
15626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15627 }
15628 arg1 = reinterpret_cast< wxImage * >(argp1);
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 delete arg1;
15632
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 resultobj = SWIG_Py_Void();
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15644 PyObject *resultobj = 0;
15645 wxString *arg1 = 0 ;
15646 wxString *arg2 = 0 ;
15647 int arg3 = (int) -1 ;
15648 wxImage *result = 0 ;
15649 bool temp1 = false ;
15650 bool temp2 = false ;
15651 int val3 ;
15652 int ecode3 = 0 ;
15653 PyObject * obj0 = 0 ;
15654 PyObject * obj1 = 0 ;
15655 PyObject * obj2 = 0 ;
15656 char * kwnames[] = {
15657 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15658 };
15659
15660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15661 {
15662 arg1 = wxString_in_helper(obj0);
15663 if (arg1 == NULL) SWIG_fail;
15664 temp1 = true;
15665 }
15666 {
15667 arg2 = wxString_in_helper(obj1);
15668 if (arg2 == NULL) SWIG_fail;
15669 temp2 = true;
15670 }
15671 if (obj2) {
15672 ecode3 = SWIG_AsVal_int(obj2, &val3);
15673 if (!SWIG_IsOK(ecode3)) {
15674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15675 }
15676 arg3 = static_cast< int >(val3);
15677 }
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15685 {
15686 if (temp1)
15687 delete arg1;
15688 }
15689 {
15690 if (temp2)
15691 delete arg2;
15692 }
15693 return resultobj;
15694 fail:
15695 {
15696 if (temp1)
15697 delete arg1;
15698 }
15699 {
15700 if (temp2)
15701 delete arg2;
15702 }
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15708 PyObject *resultobj = 0;
15709 wxInputStream *arg1 = 0 ;
15710 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15711 int arg3 = (int) -1 ;
15712 wxImage *result = 0 ;
15713 wxPyInputStream *temp1 ;
15714 bool created1 ;
15715 long val2 ;
15716 int ecode2 = 0 ;
15717 int val3 ;
15718 int ecode3 = 0 ;
15719 PyObject * obj0 = 0 ;
15720 PyObject * obj1 = 0 ;
15721 PyObject * obj2 = 0 ;
15722 char * kwnames[] = {
15723 (char *) "stream",(char *) "type",(char *) "index", NULL
15724 };
15725
15726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15727 {
15728 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15729 arg1 = temp1->m_wxis;
15730 created1 = false;
15731 } else {
15732 PyErr_Clear(); // clear the failure of the wxPyConvert above
15733 arg1 = wxPyCBInputStream_create(obj0, false);
15734 if (arg1 == NULL) {
15735 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15736 SWIG_fail;
15737 }
15738 created1 = true;
15739 }
15740 }
15741 if (obj1) {
15742 ecode2 = SWIG_AsVal_long(obj1, &val2);
15743 if (!SWIG_IsOK(ecode2)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15745 }
15746 arg2 = static_cast< long >(val2);
15747 }
15748 if (obj2) {
15749 ecode3 = SWIG_AsVal_int(obj2, &val3);
15750 if (!SWIG_IsOK(ecode3)) {
15751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15752 }
15753 arg3 = static_cast< int >(val3);
15754 }
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15758 wxPyEndAllowThreads(__tstate);
15759 if (PyErr_Occurred()) SWIG_fail;
15760 }
15761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15762 {
15763 if (created1) delete arg1;
15764 }
15765 return resultobj;
15766 fail:
15767 {
15768 if (created1) delete arg1;
15769 }
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15775 PyObject *resultobj = 0;
15776 wxInputStream *arg1 = 0 ;
15777 wxString *arg2 = 0 ;
15778 int arg3 = (int) -1 ;
15779 wxImage *result = 0 ;
15780 wxPyInputStream *temp1 ;
15781 bool created1 ;
15782 bool temp2 = false ;
15783 int val3 ;
15784 int ecode3 = 0 ;
15785 PyObject * obj0 = 0 ;
15786 PyObject * obj1 = 0 ;
15787 PyObject * obj2 = 0 ;
15788 char * kwnames[] = {
15789 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15790 };
15791
15792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15793 {
15794 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15795 arg1 = temp1->m_wxis;
15796 created1 = false;
15797 } else {
15798 PyErr_Clear(); // clear the failure of the wxPyConvert above
15799 arg1 = wxPyCBInputStream_create(obj0, false);
15800 if (arg1 == NULL) {
15801 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15802 SWIG_fail;
15803 }
15804 created1 = true;
15805 }
15806 }
15807 {
15808 arg2 = wxString_in_helper(obj1);
15809 if (arg2 == NULL) SWIG_fail;
15810 temp2 = true;
15811 }
15812 if (obj2) {
15813 ecode3 = SWIG_AsVal_int(obj2, &val3);
15814 if (!SWIG_IsOK(ecode3)) {
15815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15816 }
15817 arg3 = static_cast< int >(val3);
15818 }
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15826 {
15827 if (created1) delete arg1;
15828 }
15829 {
15830 if (temp2)
15831 delete arg2;
15832 }
15833 return resultobj;
15834 fail:
15835 {
15836 if (created1) delete arg1;
15837 }
15838 {
15839 if (temp2)
15840 delete arg2;
15841 }
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 int arg1 = (int) 0 ;
15849 int arg2 = (int) 0 ;
15850 bool arg3 = (bool) true ;
15851 wxImage *result = 0 ;
15852 int val1 ;
15853 int ecode1 = 0 ;
15854 int val2 ;
15855 int ecode2 = 0 ;
15856 bool val3 ;
15857 int ecode3 = 0 ;
15858 PyObject * obj0 = 0 ;
15859 PyObject * obj1 = 0 ;
15860 PyObject * obj2 = 0 ;
15861 char * kwnames[] = {
15862 (char *) "width",(char *) "height",(char *) "clear", NULL
15863 };
15864
15865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15866 if (obj0) {
15867 ecode1 = SWIG_AsVal_int(obj0, &val1);
15868 if (!SWIG_IsOK(ecode1)) {
15869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15870 }
15871 arg1 = static_cast< int >(val1);
15872 }
15873 if (obj1) {
15874 ecode2 = SWIG_AsVal_int(obj1, &val2);
15875 if (!SWIG_IsOK(ecode2)) {
15876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15877 }
15878 arg2 = static_cast< int >(val2);
15879 }
15880 if (obj2) {
15881 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15882 if (!SWIG_IsOK(ecode3)) {
15883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15884 }
15885 arg3 = static_cast< bool >(val3);
15886 }
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj = 0;
15902 wxBitmap *arg1 = 0 ;
15903 wxImage *result = 0 ;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 PyObject * obj0 = 0 ;
15907 char * kwnames[] = {
15908 (char *) "bitmap", NULL
15909 };
15910
15911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15912 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15913 if (!SWIG_IsOK(res1)) {
15914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15915 }
15916 if (!argp1) {
15917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15918 }
15919 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15920 {
15921 if (!wxPyCheckForApp()) SWIG_fail;
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15935 PyObject *resultobj = 0;
15936 int arg1 ;
15937 int arg2 ;
15938 buffer arg3 ;
15939 int arg4 ;
15940 wxImage *result = 0 ;
15941 int val1 ;
15942 int ecode1 = 0 ;
15943 int val2 ;
15944 int ecode2 = 0 ;
15945 Py_ssize_t temp3 ;
15946 PyObject * obj0 = 0 ;
15947 PyObject * obj1 = 0 ;
15948 PyObject * obj2 = 0 ;
15949 char * kwnames[] = {
15950 (char *) "width",(char *) "height",(char *) "data", NULL
15951 };
15952
15953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15954 ecode1 = SWIG_AsVal_int(obj0, &val1);
15955 if (!SWIG_IsOK(ecode1)) {
15956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15957 }
15958 arg1 = static_cast< int >(val1);
15959 ecode2 = SWIG_AsVal_int(obj1, &val2);
15960 if (!SWIG_IsOK(ecode2)) {
15961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15962 }
15963 arg2 = static_cast< int >(val2);
15964 {
15965 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15966 arg4 = (int)temp3;
15967 }
15968 {
15969 PyThreadState* __tstate = wxPyBeginAllowThreads();
15970 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15971 wxPyEndAllowThreads(__tstate);
15972 if (PyErr_Occurred()) SWIG_fail;
15973 }
15974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15982 PyObject *resultobj = 0;
15983 int arg1 ;
15984 int arg2 ;
15985 buffer arg3 ;
15986 int arg4 ;
15987 buffer arg5 ;
15988 int arg6 ;
15989 wxImage *result = 0 ;
15990 int val1 ;
15991 int ecode1 = 0 ;
15992 int val2 ;
15993 int ecode2 = 0 ;
15994 Py_ssize_t temp3 ;
15995 Py_ssize_t temp5 ;
15996 PyObject * obj0 = 0 ;
15997 PyObject * obj1 = 0 ;
15998 PyObject * obj2 = 0 ;
15999 PyObject * obj3 = 0 ;
16000 char * kwnames[] = {
16001 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16002 };
16003
16004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16005 ecode1 = SWIG_AsVal_int(obj0, &val1);
16006 if (!SWIG_IsOK(ecode1)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16008 }
16009 arg1 = static_cast< int >(val1);
16010 ecode2 = SWIG_AsVal_int(obj1, &val2);
16011 if (!SWIG_IsOK(ecode2)) {
16012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16013 }
16014 arg2 = static_cast< int >(val2);
16015 {
16016 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16017 arg4 = (int)temp3;
16018 }
16019 {
16020 if (obj3 != Py_None) {
16021 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16022 arg6 = (int)temp5;
16023 }
16024 }
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxImage *arg1 = (wxImage *) 0 ;
16041 int arg2 ;
16042 int arg3 ;
16043 bool arg4 = (bool) true ;
16044 void *argp1 = 0 ;
16045 int res1 = 0 ;
16046 int val2 ;
16047 int ecode2 = 0 ;
16048 int val3 ;
16049 int ecode3 = 0 ;
16050 bool val4 ;
16051 int ecode4 = 0 ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 PyObject * obj2 = 0 ;
16055 PyObject * obj3 = 0 ;
16056 char * kwnames[] = {
16057 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16058 };
16059
16060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16062 if (!SWIG_IsOK(res1)) {
16063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16064 }
16065 arg1 = reinterpret_cast< wxImage * >(argp1);
16066 ecode2 = SWIG_AsVal_int(obj1, &val2);
16067 if (!SWIG_IsOK(ecode2)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16069 }
16070 arg2 = static_cast< int >(val2);
16071 ecode3 = SWIG_AsVal_int(obj2, &val3);
16072 if (!SWIG_IsOK(ecode3)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16074 }
16075 arg3 = static_cast< int >(val3);
16076 if (obj3) {
16077 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16078 if (!SWIG_IsOK(ecode4)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16080 }
16081 arg4 = static_cast< bool >(val4);
16082 }
16083 {
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 (arg1)->Create(arg2,arg3,arg4);
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 resultobj = SWIG_Py_Void();
16090 return resultobj;
16091 fail:
16092 return NULL;
16093 }
16094
16095
16096 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16097 PyObject *resultobj = 0;
16098 wxImage *arg1 = (wxImage *) 0 ;
16099 void *argp1 = 0 ;
16100 int res1 = 0 ;
16101 PyObject *swig_obj[1] ;
16102
16103 if (!args) SWIG_fail;
16104 swig_obj[0] = args;
16105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16106 if (!SWIG_IsOK(res1)) {
16107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16108 }
16109 arg1 = reinterpret_cast< wxImage * >(argp1);
16110 {
16111 PyThreadState* __tstate = wxPyBeginAllowThreads();
16112 (arg1)->Destroy();
16113 wxPyEndAllowThreads(__tstate);
16114 if (PyErr_Occurred()) SWIG_fail;
16115 }
16116 resultobj = SWIG_Py_Void();
16117 return resultobj;
16118 fail:
16119 return NULL;
16120 }
16121
16122
16123 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16124 PyObject *resultobj = 0;
16125 wxImage *arg1 = (wxImage *) 0 ;
16126 int arg2 ;
16127 int arg3 ;
16128 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16129 SwigValueWrapper<wxImage > result;
16130 void *argp1 = 0 ;
16131 int res1 = 0 ;
16132 int val2 ;
16133 int ecode2 = 0 ;
16134 int val3 ;
16135 int ecode3 = 0 ;
16136 int val4 ;
16137 int ecode4 = 0 ;
16138 PyObject * obj0 = 0 ;
16139 PyObject * obj1 = 0 ;
16140 PyObject * obj2 = 0 ;
16141 PyObject * obj3 = 0 ;
16142 char * kwnames[] = {
16143 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16144 };
16145
16146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16150 }
16151 arg1 = reinterpret_cast< wxImage * >(argp1);
16152 ecode2 = SWIG_AsVal_int(obj1, &val2);
16153 if (!SWIG_IsOK(ecode2)) {
16154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16155 }
16156 arg2 = static_cast< int >(val2);
16157 ecode3 = SWIG_AsVal_int(obj2, &val3);
16158 if (!SWIG_IsOK(ecode3)) {
16159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16160 }
16161 arg3 = static_cast< int >(val3);
16162 if (obj3) {
16163 ecode4 = SWIG_AsVal_int(obj3, &val4);
16164 if (!SWIG_IsOK(ecode4)) {
16165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16166 }
16167 arg4 = static_cast< int >(val4);
16168 }
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 result = (arg1)->Scale(arg2,arg3,arg4);
16172 wxPyEndAllowThreads(__tstate);
16173 if (PyErr_Occurred()) SWIG_fail;
16174 }
16175 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16176 return resultobj;
16177 fail:
16178 return NULL;
16179 }
16180
16181
16182 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16183 PyObject *resultobj = 0;
16184 wxImage *arg1 = (wxImage *) 0 ;
16185 int arg2 ;
16186 int arg3 ;
16187 SwigValueWrapper<wxImage > result;
16188 void *argp1 = 0 ;
16189 int res1 = 0 ;
16190 int val2 ;
16191 int ecode2 = 0 ;
16192 int val3 ;
16193 int ecode3 = 0 ;
16194 PyObject * obj0 = 0 ;
16195 PyObject * obj1 = 0 ;
16196 PyObject * obj2 = 0 ;
16197 char * kwnames[] = {
16198 (char *) "self",(char *) "width",(char *) "height", NULL
16199 };
16200
16201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16203 if (!SWIG_IsOK(res1)) {
16204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16205 }
16206 arg1 = reinterpret_cast< wxImage * >(argp1);
16207 ecode2 = SWIG_AsVal_int(obj1, &val2);
16208 if (!SWIG_IsOK(ecode2)) {
16209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16210 }
16211 arg2 = static_cast< int >(val2);
16212 ecode3 = SWIG_AsVal_int(obj2, &val3);
16213 if (!SWIG_IsOK(ecode3)) {
16214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16215 }
16216 arg3 = static_cast< int >(val3);
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16220 wxPyEndAllowThreads(__tstate);
16221 if (PyErr_Occurred()) SWIG_fail;
16222 }
16223 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16224 return resultobj;
16225 fail:
16226 return NULL;
16227 }
16228
16229
16230 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj = 0;
16232 wxImage *arg1 = (wxImage *) 0 ;
16233 int arg2 ;
16234 int arg3 ;
16235 SwigValueWrapper<wxImage > result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 int val2 ;
16239 int ecode2 = 0 ;
16240 int val3 ;
16241 int ecode3 = 0 ;
16242 PyObject * obj0 = 0 ;
16243 PyObject * obj1 = 0 ;
16244 PyObject * obj2 = 0 ;
16245 char * kwnames[] = {
16246 (char *) "self",(char *) "width",(char *) "height", NULL
16247 };
16248
16249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16251 if (!SWIG_IsOK(res1)) {
16252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16253 }
16254 arg1 = reinterpret_cast< wxImage * >(argp1);
16255 ecode2 = SWIG_AsVal_int(obj1, &val2);
16256 if (!SWIG_IsOK(ecode2)) {
16257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16258 }
16259 arg2 = static_cast< int >(val2);
16260 ecode3 = SWIG_AsVal_int(obj2, &val3);
16261 if (!SWIG_IsOK(ecode3)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16263 }
16264 arg3 = static_cast< int >(val3);
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16268 wxPyEndAllowThreads(__tstate);
16269 if (PyErr_Occurred()) SWIG_fail;
16270 }
16271 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16272 return resultobj;
16273 fail:
16274 return NULL;
16275 }
16276
16277
16278 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16279 PyObject *resultobj = 0;
16280 wxImage *arg1 = (wxImage *) 0 ;
16281 int arg2 ;
16282 SwigValueWrapper<wxImage > result;
16283 void *argp1 = 0 ;
16284 int res1 = 0 ;
16285 int val2 ;
16286 int ecode2 = 0 ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 char * kwnames[] = {
16290 (char *) "self",(char *) "radius", NULL
16291 };
16292
16293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16297 }
16298 arg1 = reinterpret_cast< wxImage * >(argp1);
16299 ecode2 = SWIG_AsVal_int(obj1, &val2);
16300 if (!SWIG_IsOK(ecode2)) {
16301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16302 }
16303 arg2 = static_cast< int >(val2);
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 result = (arg1)->Blur(arg2);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj = 0;
16319 wxImage *arg1 = (wxImage *) 0 ;
16320 int arg2 ;
16321 SwigValueWrapper<wxImage > result;
16322 void *argp1 = 0 ;
16323 int res1 = 0 ;
16324 int val2 ;
16325 int ecode2 = 0 ;
16326 PyObject * obj0 = 0 ;
16327 PyObject * obj1 = 0 ;
16328 char * kwnames[] = {
16329 (char *) "self",(char *) "radius", NULL
16330 };
16331
16332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16334 if (!SWIG_IsOK(res1)) {
16335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16336 }
16337 arg1 = reinterpret_cast< wxImage * >(argp1);
16338 ecode2 = SWIG_AsVal_int(obj1, &val2);
16339 if (!SWIG_IsOK(ecode2)) {
16340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16341 }
16342 arg2 = static_cast< int >(val2);
16343 {
16344 PyThreadState* __tstate = wxPyBeginAllowThreads();
16345 result = (arg1)->BlurHorizontal(arg2);
16346 wxPyEndAllowThreads(__tstate);
16347 if (PyErr_Occurred()) SWIG_fail;
16348 }
16349 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16350 return resultobj;
16351 fail:
16352 return NULL;
16353 }
16354
16355
16356 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16357 PyObject *resultobj = 0;
16358 wxImage *arg1 = (wxImage *) 0 ;
16359 int arg2 ;
16360 SwigValueWrapper<wxImage > result;
16361 void *argp1 = 0 ;
16362 int res1 = 0 ;
16363 int val2 ;
16364 int ecode2 = 0 ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 char * kwnames[] = {
16368 (char *) "self",(char *) "radius", NULL
16369 };
16370
16371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16373 if (!SWIG_IsOK(res1)) {
16374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16375 }
16376 arg1 = reinterpret_cast< wxImage * >(argp1);
16377 ecode2 = SWIG_AsVal_int(obj1, &val2);
16378 if (!SWIG_IsOK(ecode2)) {
16379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16380 }
16381 arg2 = static_cast< int >(val2);
16382 {
16383 PyThreadState* __tstate = wxPyBeginAllowThreads();
16384 result = (arg1)->BlurVertical(arg2);
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj = 0;
16397 wxImage *arg1 = (wxImage *) 0 ;
16398 int arg2 ;
16399 int arg3 ;
16400 SwigValueWrapper<wxImage > result;
16401 void *argp1 = 0 ;
16402 int res1 = 0 ;
16403 int val2 ;
16404 int ecode2 = 0 ;
16405 int val3 ;
16406 int ecode3 = 0 ;
16407 PyObject * obj0 = 0 ;
16408 PyObject * obj1 = 0 ;
16409 PyObject * obj2 = 0 ;
16410 char * kwnames[] = {
16411 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16412 };
16413
16414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16416 if (!SWIG_IsOK(res1)) {
16417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16418 }
16419 arg1 = reinterpret_cast< wxImage * >(argp1);
16420 ecode2 = SWIG_AsVal_int(obj1, &val2);
16421 if (!SWIG_IsOK(ecode2)) {
16422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16423 }
16424 arg2 = static_cast< int >(val2);
16425 ecode3 = SWIG_AsVal_int(obj2, &val3);
16426 if (!SWIG_IsOK(ecode3)) {
16427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16428 }
16429 arg3 = static_cast< int >(val3);
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj = 0;
16445 wxImage *arg1 = (wxImage *) 0 ;
16446 int arg2 ;
16447 int arg3 ;
16448 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16449 wxImage *result = 0 ;
16450 void *argp1 = 0 ;
16451 int res1 = 0 ;
16452 int val2 ;
16453 int ecode2 = 0 ;
16454 int val3 ;
16455 int ecode3 = 0 ;
16456 int val4 ;
16457 int ecode4 = 0 ;
16458 PyObject * obj0 = 0 ;
16459 PyObject * obj1 = 0 ;
16460 PyObject * obj2 = 0 ;
16461 PyObject * obj3 = 0 ;
16462 char * kwnames[] = {
16463 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16464 };
16465
16466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16468 if (!SWIG_IsOK(res1)) {
16469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16470 }
16471 arg1 = reinterpret_cast< wxImage * >(argp1);
16472 ecode2 = SWIG_AsVal_int(obj1, &val2);
16473 if (!SWIG_IsOK(ecode2)) {
16474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16475 }
16476 arg2 = static_cast< int >(val2);
16477 ecode3 = SWIG_AsVal_int(obj2, &val3);
16478 if (!SWIG_IsOK(ecode3)) {
16479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16480 }
16481 arg3 = static_cast< int >(val3);
16482 if (obj3) {
16483 ecode4 = SWIG_AsVal_int(obj3, &val4);
16484 if (!SWIG_IsOK(ecode4)) {
16485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16486 }
16487 arg4 = static_cast< int >(val4);
16488 }
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 {
16492 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16493 result = (wxImage *) &_result_ref;
16494 }
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj = 0;
16507 wxImage *arg1 = (wxImage *) 0 ;
16508 wxSize *arg2 = 0 ;
16509 wxPoint *arg3 = 0 ;
16510 int arg4 = (int) -1 ;
16511 int arg5 = (int) -1 ;
16512 int arg6 = (int) -1 ;
16513 wxImage *result = 0 ;
16514 void *argp1 = 0 ;
16515 int res1 = 0 ;
16516 wxSize temp2 ;
16517 wxPoint temp3 ;
16518 int val4 ;
16519 int ecode4 = 0 ;
16520 int val5 ;
16521 int ecode5 = 0 ;
16522 int val6 ;
16523 int ecode6 = 0 ;
16524 PyObject * obj0 = 0 ;
16525 PyObject * obj1 = 0 ;
16526 PyObject * obj2 = 0 ;
16527 PyObject * obj3 = 0 ;
16528 PyObject * obj4 = 0 ;
16529 PyObject * obj5 = 0 ;
16530 char * kwnames[] = {
16531 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16532 };
16533
16534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16536 if (!SWIG_IsOK(res1)) {
16537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16538 }
16539 arg1 = reinterpret_cast< wxImage * >(argp1);
16540 {
16541 arg2 = &temp2;
16542 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16543 }
16544 {
16545 arg3 = &temp3;
16546 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16547 }
16548 if (obj3) {
16549 ecode4 = SWIG_AsVal_int(obj3, &val4);
16550 if (!SWIG_IsOK(ecode4)) {
16551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16552 }
16553 arg4 = static_cast< int >(val4);
16554 }
16555 if (obj4) {
16556 ecode5 = SWIG_AsVal_int(obj4, &val5);
16557 if (!SWIG_IsOK(ecode5)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16559 }
16560 arg5 = static_cast< int >(val5);
16561 }
16562 if (obj5) {
16563 ecode6 = SWIG_AsVal_int(obj5, &val6);
16564 if (!SWIG_IsOK(ecode6)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16566 }
16567 arg6 = static_cast< int >(val6);
16568 }
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 {
16572 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16573 result = (wxImage *) &_result_ref;
16574 }
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16579 return resultobj;
16580 fail:
16581 return NULL;
16582 }
16583
16584
16585 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj = 0;
16587 wxImage *arg1 = (wxImage *) 0 ;
16588 int arg2 ;
16589 int arg3 ;
16590 byte arg4 ;
16591 byte arg5 ;
16592 byte arg6 ;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 int val2 ;
16596 int ecode2 = 0 ;
16597 int val3 ;
16598 int ecode3 = 0 ;
16599 unsigned char val4 ;
16600 int ecode4 = 0 ;
16601 unsigned char val5 ;
16602 int ecode5 = 0 ;
16603 unsigned char val6 ;
16604 int ecode6 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 PyObject * obj3 = 0 ;
16609 PyObject * obj4 = 0 ;
16610 PyObject * obj5 = 0 ;
16611 char * kwnames[] = {
16612 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16613 };
16614
16615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16617 if (!SWIG_IsOK(res1)) {
16618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16619 }
16620 arg1 = reinterpret_cast< wxImage * >(argp1);
16621 ecode2 = SWIG_AsVal_int(obj1, &val2);
16622 if (!SWIG_IsOK(ecode2)) {
16623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16624 }
16625 arg2 = static_cast< int >(val2);
16626 ecode3 = SWIG_AsVal_int(obj2, &val3);
16627 if (!SWIG_IsOK(ecode3)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16629 }
16630 arg3 = static_cast< int >(val3);
16631 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16632 if (!SWIG_IsOK(ecode4)) {
16633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16634 }
16635 arg4 = static_cast< byte >(val4);
16636 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16637 if (!SWIG_IsOK(ecode5)) {
16638 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16639 }
16640 arg5 = static_cast< byte >(val5);
16641 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16642 if (!SWIG_IsOK(ecode6)) {
16643 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16644 }
16645 arg6 = static_cast< byte >(val6);
16646 {
16647 PyThreadState* __tstate = wxPyBeginAllowThreads();
16648 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 resultobj = SWIG_Py_Void();
16653 return resultobj;
16654 fail:
16655 return NULL;
16656 }
16657
16658
16659 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16660 PyObject *resultobj = 0;
16661 wxImage *arg1 = (wxImage *) 0 ;
16662 wxRect *arg2 = 0 ;
16663 byte arg3 ;
16664 byte arg4 ;
16665 byte arg5 ;
16666 void *argp1 = 0 ;
16667 int res1 = 0 ;
16668 wxRect temp2 ;
16669 unsigned char val3 ;
16670 int ecode3 = 0 ;
16671 unsigned char val4 ;
16672 int ecode4 = 0 ;
16673 unsigned char val5 ;
16674 int ecode5 = 0 ;
16675 PyObject * obj0 = 0 ;
16676 PyObject * obj1 = 0 ;
16677 PyObject * obj2 = 0 ;
16678 PyObject * obj3 = 0 ;
16679 PyObject * obj4 = 0 ;
16680 char * kwnames[] = {
16681 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16682 };
16683
16684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16686 if (!SWIG_IsOK(res1)) {
16687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16688 }
16689 arg1 = reinterpret_cast< wxImage * >(argp1);
16690 {
16691 arg2 = &temp2;
16692 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16693 }
16694 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16695 if (!SWIG_IsOK(ecode3)) {
16696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16697 }
16698 arg3 = static_cast< byte >(val3);
16699 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16700 if (!SWIG_IsOK(ecode4)) {
16701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16702 }
16703 arg4 = static_cast< byte >(val4);
16704 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16705 if (!SWIG_IsOK(ecode5)) {
16706 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16707 }
16708 arg5 = static_cast< byte >(val5);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_Py_Void();
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = 0;
16724 wxImage *arg1 = (wxImage *) 0 ;
16725 int arg2 ;
16726 int arg3 ;
16727 byte result;
16728 void *argp1 = 0 ;
16729 int res1 = 0 ;
16730 int val2 ;
16731 int ecode2 = 0 ;
16732 int val3 ;
16733 int ecode3 = 0 ;
16734 PyObject * obj0 = 0 ;
16735 PyObject * obj1 = 0 ;
16736 PyObject * obj2 = 0 ;
16737 char * kwnames[] = {
16738 (char *) "self",(char *) "x",(char *) "y", NULL
16739 };
16740
16741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16743 if (!SWIG_IsOK(res1)) {
16744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16745 }
16746 arg1 = reinterpret_cast< wxImage * >(argp1);
16747 ecode2 = SWIG_AsVal_int(obj1, &val2);
16748 if (!SWIG_IsOK(ecode2)) {
16749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16750 }
16751 arg2 = static_cast< int >(val2);
16752 ecode3 = SWIG_AsVal_int(obj2, &val3);
16753 if (!SWIG_IsOK(ecode3)) {
16754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16755 }
16756 arg3 = static_cast< int >(val3);
16757 {
16758 PyThreadState* __tstate = wxPyBeginAllowThreads();
16759 result = (byte)(arg1)->GetRed(arg2,arg3);
16760 wxPyEndAllowThreads(__tstate);
16761 if (PyErr_Occurred()) SWIG_fail;
16762 }
16763 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16764 return resultobj;
16765 fail:
16766 return NULL;
16767 }
16768
16769
16770 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16771 PyObject *resultobj = 0;
16772 wxImage *arg1 = (wxImage *) 0 ;
16773 int arg2 ;
16774 int arg3 ;
16775 byte result;
16776 void *argp1 = 0 ;
16777 int res1 = 0 ;
16778 int val2 ;
16779 int ecode2 = 0 ;
16780 int val3 ;
16781 int ecode3 = 0 ;
16782 PyObject * obj0 = 0 ;
16783 PyObject * obj1 = 0 ;
16784 PyObject * obj2 = 0 ;
16785 char * kwnames[] = {
16786 (char *) "self",(char *) "x",(char *) "y", NULL
16787 };
16788
16789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16791 if (!SWIG_IsOK(res1)) {
16792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16793 }
16794 arg1 = reinterpret_cast< wxImage * >(argp1);
16795 ecode2 = SWIG_AsVal_int(obj1, &val2);
16796 if (!SWIG_IsOK(ecode2)) {
16797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16798 }
16799 arg2 = static_cast< int >(val2);
16800 ecode3 = SWIG_AsVal_int(obj2, &val3);
16801 if (!SWIG_IsOK(ecode3)) {
16802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16803 }
16804 arg3 = static_cast< int >(val3);
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = (byte)(arg1)->GetGreen(arg2,arg3);
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxImage *arg1 = (wxImage *) 0 ;
16821 int arg2 ;
16822 int arg3 ;
16823 byte result;
16824 void *argp1 = 0 ;
16825 int res1 = 0 ;
16826 int val2 ;
16827 int ecode2 = 0 ;
16828 int val3 ;
16829 int ecode3 = 0 ;
16830 PyObject * obj0 = 0 ;
16831 PyObject * obj1 = 0 ;
16832 PyObject * obj2 = 0 ;
16833 char * kwnames[] = {
16834 (char *) "self",(char *) "x",(char *) "y", NULL
16835 };
16836
16837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16839 if (!SWIG_IsOK(res1)) {
16840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16841 }
16842 arg1 = reinterpret_cast< wxImage * >(argp1);
16843 ecode2 = SWIG_AsVal_int(obj1, &val2);
16844 if (!SWIG_IsOK(ecode2)) {
16845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16846 }
16847 arg2 = static_cast< int >(val2);
16848 ecode3 = SWIG_AsVal_int(obj2, &val3);
16849 if (!SWIG_IsOK(ecode3)) {
16850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16851 }
16852 arg3 = static_cast< int >(val3);
16853 {
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 result = (byte)(arg1)->GetBlue(arg2,arg3);
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj = 0;
16868 wxImage *arg1 = (wxImage *) 0 ;
16869 int arg2 ;
16870 int arg3 ;
16871 byte arg4 ;
16872 void *argp1 = 0 ;
16873 int res1 = 0 ;
16874 int val2 ;
16875 int ecode2 = 0 ;
16876 int val3 ;
16877 int ecode3 = 0 ;
16878 unsigned char val4 ;
16879 int ecode4 = 0 ;
16880 PyObject * obj0 = 0 ;
16881 PyObject * obj1 = 0 ;
16882 PyObject * obj2 = 0 ;
16883 PyObject * obj3 = 0 ;
16884 char * kwnames[] = {
16885 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16886 };
16887
16888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16892 }
16893 arg1 = reinterpret_cast< wxImage * >(argp1);
16894 ecode2 = SWIG_AsVal_int(obj1, &val2);
16895 if (!SWIG_IsOK(ecode2)) {
16896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16897 }
16898 arg2 = static_cast< int >(val2);
16899 ecode3 = SWIG_AsVal_int(obj2, &val3);
16900 if (!SWIG_IsOK(ecode3)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16902 }
16903 arg3 = static_cast< int >(val3);
16904 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16905 if (!SWIG_IsOK(ecode4)) {
16906 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16907 }
16908 arg4 = static_cast< byte >(val4);
16909 {
16910 PyThreadState* __tstate = wxPyBeginAllowThreads();
16911 (arg1)->SetAlpha(arg2,arg3,arg4);
16912 wxPyEndAllowThreads(__tstate);
16913 if (PyErr_Occurred()) SWIG_fail;
16914 }
16915 resultobj = SWIG_Py_Void();
16916 return resultobj;
16917 fail:
16918 return NULL;
16919 }
16920
16921
16922 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16923 PyObject *resultobj = 0;
16924 wxImage *arg1 = (wxImage *) 0 ;
16925 int arg2 ;
16926 int arg3 ;
16927 byte result;
16928 void *argp1 = 0 ;
16929 int res1 = 0 ;
16930 int val2 ;
16931 int ecode2 = 0 ;
16932 int val3 ;
16933 int ecode3 = 0 ;
16934 PyObject * obj0 = 0 ;
16935 PyObject * obj1 = 0 ;
16936 PyObject * obj2 = 0 ;
16937 char * kwnames[] = {
16938 (char *) "self",(char *) "x",(char *) "y", NULL
16939 };
16940
16941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16943 if (!SWIG_IsOK(res1)) {
16944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16945 }
16946 arg1 = reinterpret_cast< wxImage * >(argp1);
16947 ecode2 = SWIG_AsVal_int(obj1, &val2);
16948 if (!SWIG_IsOK(ecode2)) {
16949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16950 }
16951 arg2 = static_cast< int >(val2);
16952 ecode3 = SWIG_AsVal_int(obj2, &val3);
16953 if (!SWIG_IsOK(ecode3)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16955 }
16956 arg3 = static_cast< int >(val3);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16971 PyObject *resultobj = 0;
16972 wxImage *arg1 = (wxImage *) 0 ;
16973 bool result;
16974 void *argp1 = 0 ;
16975 int res1 = 0 ;
16976 PyObject *swig_obj[1] ;
16977
16978 if (!args) SWIG_fail;
16979 swig_obj[0] = args;
16980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16981 if (!SWIG_IsOK(res1)) {
16982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16983 }
16984 arg1 = reinterpret_cast< wxImage * >(argp1);
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (bool)(arg1)->HasAlpha();
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 {
16992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16993 }
16994 return resultobj;
16995 fail:
16996 return NULL;
16997 }
16998
16999
17000 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17001 PyObject *resultobj = 0;
17002 wxImage *arg1 = (wxImage *) 0 ;
17003 void *argp1 = 0 ;
17004 int res1 = 0 ;
17005 PyObject *swig_obj[1] ;
17006
17007 if (!args) SWIG_fail;
17008 swig_obj[0] = args;
17009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17010 if (!SWIG_IsOK(res1)) {
17011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17012 }
17013 arg1 = reinterpret_cast< wxImage * >(argp1);
17014 {
17015 PyThreadState* __tstate = wxPyBeginAllowThreads();
17016 (arg1)->InitAlpha();
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 resultobj = SWIG_Py_Void();
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxImage *arg1 = (wxImage *) 0 ;
17030 int arg2 ;
17031 int arg3 ;
17032 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17033 bool result;
17034 void *argp1 = 0 ;
17035 int res1 = 0 ;
17036 int val2 ;
17037 int ecode2 = 0 ;
17038 int val3 ;
17039 int ecode3 = 0 ;
17040 unsigned char val4 ;
17041 int ecode4 = 0 ;
17042 PyObject * obj0 = 0 ;
17043 PyObject * obj1 = 0 ;
17044 PyObject * obj2 = 0 ;
17045 PyObject * obj3 = 0 ;
17046 char * kwnames[] = {
17047 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17048 };
17049
17050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17052 if (!SWIG_IsOK(res1)) {
17053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17054 }
17055 arg1 = reinterpret_cast< wxImage * >(argp1);
17056 ecode2 = SWIG_AsVal_int(obj1, &val2);
17057 if (!SWIG_IsOK(ecode2)) {
17058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17059 }
17060 arg2 = static_cast< int >(val2);
17061 ecode3 = SWIG_AsVal_int(obj2, &val3);
17062 if (!SWIG_IsOK(ecode3)) {
17063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17064 }
17065 arg3 = static_cast< int >(val3);
17066 if (obj3) {
17067 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17068 if (!SWIG_IsOK(ecode4)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17070 }
17071 arg4 = static_cast< byte >(val4);
17072 }
17073 {
17074 PyThreadState* __tstate = wxPyBeginAllowThreads();
17075 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17076 wxPyEndAllowThreads(__tstate);
17077 if (PyErr_Occurred()) SWIG_fail;
17078 }
17079 {
17080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17081 }
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17089 PyObject *resultobj = 0;
17090 wxImage *arg1 = (wxImage *) 0 ;
17091 byte *arg2 = (byte *) 0 ;
17092 byte *arg3 = (byte *) 0 ;
17093 byte *arg4 = (byte *) 0 ;
17094 byte arg5 = (byte) 0 ;
17095 byte arg6 = (byte) 0 ;
17096 byte arg7 = (byte) 0 ;
17097 bool result;
17098 void *argp1 = 0 ;
17099 int res1 = 0 ;
17100 byte temp2 ;
17101 int res2 = SWIG_TMPOBJ ;
17102 byte temp3 ;
17103 int res3 = SWIG_TMPOBJ ;
17104 byte temp4 ;
17105 int res4 = SWIG_TMPOBJ ;
17106 unsigned char val5 ;
17107 int ecode5 = 0 ;
17108 unsigned char val6 ;
17109 int ecode6 = 0 ;
17110 unsigned char val7 ;
17111 int ecode7 = 0 ;
17112 PyObject * obj0 = 0 ;
17113 PyObject * obj1 = 0 ;
17114 PyObject * obj2 = 0 ;
17115 PyObject * obj3 = 0 ;
17116 char * kwnames[] = {
17117 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17118 };
17119
17120 arg2 = &temp2;
17121 arg3 = &temp3;
17122 arg4 = &temp4;
17123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17125 if (!SWIG_IsOK(res1)) {
17126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17127 }
17128 arg1 = reinterpret_cast< wxImage * >(argp1);
17129 if (obj1) {
17130 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17131 if (!SWIG_IsOK(ecode5)) {
17132 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17133 }
17134 arg5 = static_cast< byte >(val5);
17135 }
17136 if (obj2) {
17137 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17138 if (!SWIG_IsOK(ecode6)) {
17139 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17140 }
17141 arg6 = static_cast< byte >(val6);
17142 }
17143 if (obj3) {
17144 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17145 if (!SWIG_IsOK(ecode7)) {
17146 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17147 }
17148 arg7 = static_cast< byte >(val7);
17149 }
17150 {
17151 PyThreadState* __tstate = wxPyBeginAllowThreads();
17152 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 {
17157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17158 }
17159 if (SWIG_IsTmpObj(res2)) {
17160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17161 } else {
17162 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17164 }
17165 if (SWIG_IsTmpObj(res3)) {
17166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17167 } else {
17168 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17170 }
17171 if (SWIG_IsTmpObj(res4)) {
17172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17173 } else {
17174 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17176 }
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj = 0;
17185 wxImage *arg1 = (wxImage *) 0 ;
17186 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17187 bool result;
17188 void *argp1 = 0 ;
17189 int res1 = 0 ;
17190 unsigned char val2 ;
17191 int ecode2 = 0 ;
17192 PyObject * obj0 = 0 ;
17193 PyObject * obj1 = 0 ;
17194 char * kwnames[] = {
17195 (char *) "self",(char *) "threshold", NULL
17196 };
17197
17198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17200 if (!SWIG_IsOK(res1)) {
17201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17202 }
17203 arg1 = reinterpret_cast< wxImage * >(argp1);
17204 if (obj1) {
17205 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17206 if (!SWIG_IsOK(ecode2)) {
17207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17208 }
17209 arg2 = static_cast< byte >(val2);
17210 }
17211 {
17212 PyThreadState* __tstate = wxPyBeginAllowThreads();
17213 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 {
17218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17219 }
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj = 0;
17228 wxImage *arg1 = (wxImage *) 0 ;
17229 byte arg2 ;
17230 byte arg3 ;
17231 byte arg4 ;
17232 bool result;
17233 void *argp1 = 0 ;
17234 int res1 = 0 ;
17235 unsigned char val2 ;
17236 int ecode2 = 0 ;
17237 unsigned char val3 ;
17238 int ecode3 = 0 ;
17239 unsigned char val4 ;
17240 int ecode4 = 0 ;
17241 PyObject * obj0 = 0 ;
17242 PyObject * obj1 = 0 ;
17243 PyObject * obj2 = 0 ;
17244 PyObject * obj3 = 0 ;
17245 char * kwnames[] = {
17246 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17247 };
17248
17249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17251 if (!SWIG_IsOK(res1)) {
17252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17253 }
17254 arg1 = reinterpret_cast< wxImage * >(argp1);
17255 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17256 if (!SWIG_IsOK(ecode2)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17258 }
17259 arg2 = static_cast< byte >(val2);
17260 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17261 if (!SWIG_IsOK(ecode3)) {
17262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17263 }
17264 arg3 = static_cast< byte >(val3);
17265 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17266 if (!SWIG_IsOK(ecode4)) {
17267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17268 }
17269 arg4 = static_cast< byte >(val4);
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 {
17277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17278 }
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj = 0;
17287 wxImage *arg1 = (wxImage *) 0 ;
17288 wxImage *arg2 = 0 ;
17289 byte arg3 ;
17290 byte arg4 ;
17291 byte arg5 ;
17292 bool result;
17293 void *argp1 = 0 ;
17294 int res1 = 0 ;
17295 void *argp2 = 0 ;
17296 int res2 = 0 ;
17297 unsigned char val3 ;
17298 int ecode3 = 0 ;
17299 unsigned char val4 ;
17300 int ecode4 = 0 ;
17301 unsigned char val5 ;
17302 int ecode5 = 0 ;
17303 PyObject * obj0 = 0 ;
17304 PyObject * obj1 = 0 ;
17305 PyObject * obj2 = 0 ;
17306 PyObject * obj3 = 0 ;
17307 PyObject * obj4 = 0 ;
17308 char * kwnames[] = {
17309 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17310 };
17311
17312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17314 if (!SWIG_IsOK(res1)) {
17315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17316 }
17317 arg1 = reinterpret_cast< wxImage * >(argp1);
17318 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17319 if (!SWIG_IsOK(res2)) {
17320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17321 }
17322 if (!argp2) {
17323 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17324 }
17325 arg2 = reinterpret_cast< wxImage * >(argp2);
17326 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17327 if (!SWIG_IsOK(ecode3)) {
17328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17329 }
17330 arg3 = static_cast< byte >(val3);
17331 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17332 if (!SWIG_IsOK(ecode4)) {
17333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17334 }
17335 arg4 = static_cast< byte >(val4);
17336 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17337 if (!SWIG_IsOK(ecode5)) {
17338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17339 }
17340 arg5 = static_cast< byte >(val5);
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 {
17348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17349 }
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj = 0;
17358 wxString *arg1 = 0 ;
17359 bool result;
17360 bool temp1 = false ;
17361 PyObject * obj0 = 0 ;
17362 char * kwnames[] = {
17363 (char *) "filename", NULL
17364 };
17365
17366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17367 {
17368 arg1 = wxString_in_helper(obj0);
17369 if (arg1 == NULL) SWIG_fail;
17370 temp1 = true;
17371 }
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17375 wxPyEndAllowThreads(__tstate);
17376 if (PyErr_Occurred()) SWIG_fail;
17377 }
17378 {
17379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17380 }
17381 {
17382 if (temp1)
17383 delete arg1;
17384 }
17385 return resultobj;
17386 fail:
17387 {
17388 if (temp1)
17389 delete arg1;
17390 }
17391 return NULL;
17392 }
17393
17394
17395 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17396 PyObject *resultobj = 0;
17397 wxString *arg1 = 0 ;
17398 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17399 int result;
17400 bool temp1 = false ;
17401 long val2 ;
17402 int ecode2 = 0 ;
17403 PyObject * obj0 = 0 ;
17404 PyObject * obj1 = 0 ;
17405 char * kwnames[] = {
17406 (char *) "filename",(char *) "type", NULL
17407 };
17408
17409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17410 {
17411 arg1 = wxString_in_helper(obj0);
17412 if (arg1 == NULL) SWIG_fail;
17413 temp1 = true;
17414 }
17415 if (obj1) {
17416 ecode2 = SWIG_AsVal_long(obj1, &val2);
17417 if (!SWIG_IsOK(ecode2)) {
17418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17419 }
17420 arg2 = static_cast< long >(val2);
17421 }
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 resultobj = SWIG_From_int(static_cast< int >(result));
17429 {
17430 if (temp1)
17431 delete arg1;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp1)
17437 delete arg1;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj = 0;
17445 wxImage *arg1 = (wxImage *) 0 ;
17446 wxString *arg2 = 0 ;
17447 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17448 int arg4 = (int) -1 ;
17449 bool result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 bool temp2 = false ;
17453 long val3 ;
17454 int ecode3 = 0 ;
17455 int val4 ;
17456 int ecode4 = 0 ;
17457 PyObject * obj0 = 0 ;
17458 PyObject * obj1 = 0 ;
17459 PyObject * obj2 = 0 ;
17460 PyObject * obj3 = 0 ;
17461 char * kwnames[] = {
17462 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17463 };
17464
17465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17467 if (!SWIG_IsOK(res1)) {
17468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17469 }
17470 arg1 = reinterpret_cast< wxImage * >(argp1);
17471 {
17472 arg2 = wxString_in_helper(obj1);
17473 if (arg2 == NULL) SWIG_fail;
17474 temp2 = true;
17475 }
17476 if (obj2) {
17477 ecode3 = SWIG_AsVal_long(obj2, &val3);
17478 if (!SWIG_IsOK(ecode3)) {
17479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17480 }
17481 arg3 = static_cast< long >(val3);
17482 }
17483 if (obj3) {
17484 ecode4 = SWIG_AsVal_int(obj3, &val4);
17485 if (!SWIG_IsOK(ecode4)) {
17486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17487 }
17488 arg4 = static_cast< int >(val4);
17489 }
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17493 wxPyEndAllowThreads(__tstate);
17494 if (PyErr_Occurred()) SWIG_fail;
17495 }
17496 {
17497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17498 }
17499 {
17500 if (temp2)
17501 delete arg2;
17502 }
17503 return resultobj;
17504 fail:
17505 {
17506 if (temp2)
17507 delete arg2;
17508 }
17509 return NULL;
17510 }
17511
17512
17513 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj = 0;
17515 wxImage *arg1 = (wxImage *) 0 ;
17516 wxString *arg2 = 0 ;
17517 wxString *arg3 = 0 ;
17518 int arg4 = (int) -1 ;
17519 bool result;
17520 void *argp1 = 0 ;
17521 int res1 = 0 ;
17522 bool temp2 = false ;
17523 bool temp3 = false ;
17524 int val4 ;
17525 int ecode4 = 0 ;
17526 PyObject * obj0 = 0 ;
17527 PyObject * obj1 = 0 ;
17528 PyObject * obj2 = 0 ;
17529 PyObject * obj3 = 0 ;
17530 char * kwnames[] = {
17531 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17532 };
17533
17534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17536 if (!SWIG_IsOK(res1)) {
17537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17538 }
17539 arg1 = reinterpret_cast< wxImage * >(argp1);
17540 {
17541 arg2 = wxString_in_helper(obj1);
17542 if (arg2 == NULL) SWIG_fail;
17543 temp2 = true;
17544 }
17545 {
17546 arg3 = wxString_in_helper(obj2);
17547 if (arg3 == NULL) SWIG_fail;
17548 temp3 = true;
17549 }
17550 if (obj3) {
17551 ecode4 = SWIG_AsVal_int(obj3, &val4);
17552 if (!SWIG_IsOK(ecode4)) {
17553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17554 }
17555 arg4 = static_cast< int >(val4);
17556 }
17557 {
17558 PyThreadState* __tstate = wxPyBeginAllowThreads();
17559 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17560 wxPyEndAllowThreads(__tstate);
17561 if (PyErr_Occurred()) SWIG_fail;
17562 }
17563 {
17564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17565 }
17566 {
17567 if (temp2)
17568 delete arg2;
17569 }
17570 {
17571 if (temp3)
17572 delete arg3;
17573 }
17574 return resultobj;
17575 fail:
17576 {
17577 if (temp2)
17578 delete arg2;
17579 }
17580 {
17581 if (temp3)
17582 delete arg3;
17583 }
17584 return NULL;
17585 }
17586
17587
17588 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17589 PyObject *resultobj = 0;
17590 wxImage *arg1 = (wxImage *) 0 ;
17591 wxString *arg2 = 0 ;
17592 int arg3 ;
17593 bool result;
17594 void *argp1 = 0 ;
17595 int res1 = 0 ;
17596 bool temp2 = false ;
17597 int val3 ;
17598 int ecode3 = 0 ;
17599 PyObject * obj0 = 0 ;
17600 PyObject * obj1 = 0 ;
17601 PyObject * obj2 = 0 ;
17602 char * kwnames[] = {
17603 (char *) "self",(char *) "name",(char *) "type", NULL
17604 };
17605
17606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17608 if (!SWIG_IsOK(res1)) {
17609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17610 }
17611 arg1 = reinterpret_cast< wxImage * >(argp1);
17612 {
17613 arg2 = wxString_in_helper(obj1);
17614 if (arg2 == NULL) SWIG_fail;
17615 temp2 = true;
17616 }
17617 ecode3 = SWIG_AsVal_int(obj2, &val3);
17618 if (!SWIG_IsOK(ecode3)) {
17619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17620 }
17621 arg3 = static_cast< int >(val3);
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 {
17629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17630 }
17631 {
17632 if (temp2)
17633 delete arg2;
17634 }
17635 return resultobj;
17636 fail:
17637 {
17638 if (temp2)
17639 delete arg2;
17640 }
17641 return NULL;
17642 }
17643
17644
17645 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17646 PyObject *resultobj = 0;
17647 wxImage *arg1 = (wxImage *) 0 ;
17648 wxString *arg2 = 0 ;
17649 wxString *arg3 = 0 ;
17650 bool result;
17651 void *argp1 = 0 ;
17652 int res1 = 0 ;
17653 bool temp2 = false ;
17654 bool temp3 = false ;
17655 PyObject * obj0 = 0 ;
17656 PyObject * obj1 = 0 ;
17657 PyObject * obj2 = 0 ;
17658 char * kwnames[] = {
17659 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17660 };
17661
17662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17664 if (!SWIG_IsOK(res1)) {
17665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17666 }
17667 arg1 = reinterpret_cast< wxImage * >(argp1);
17668 {
17669 arg2 = wxString_in_helper(obj1);
17670 if (arg2 == NULL) SWIG_fail;
17671 temp2 = true;
17672 }
17673 {
17674 arg3 = wxString_in_helper(obj2);
17675 if (arg3 == NULL) SWIG_fail;
17676 temp3 = true;
17677 }
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 {
17685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17686 }
17687 {
17688 if (temp2)
17689 delete arg2;
17690 }
17691 {
17692 if (temp3)
17693 delete arg3;
17694 }
17695 return resultobj;
17696 fail:
17697 {
17698 if (temp2)
17699 delete arg2;
17700 }
17701 {
17702 if (temp3)
17703 delete arg3;
17704 }
17705 return NULL;
17706 }
17707
17708
17709 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17710 PyObject *resultobj = 0;
17711 wxInputStream *arg1 = 0 ;
17712 bool result;
17713 wxPyInputStream *temp1 ;
17714 bool created1 ;
17715 PyObject * obj0 = 0 ;
17716 char * kwnames[] = {
17717 (char *) "stream", NULL
17718 };
17719
17720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17721 {
17722 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17723 arg1 = temp1->m_wxis;
17724 created1 = false;
17725 } else {
17726 PyErr_Clear(); // clear the failure of the wxPyConvert above
17727 arg1 = wxPyCBInputStream_create(obj0, false);
17728 if (arg1 == NULL) {
17729 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17730 SWIG_fail;
17731 }
17732 created1 = true;
17733 }
17734 }
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 result = (bool)wxImage::CanRead(*arg1);
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 {
17742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17743 }
17744 {
17745 if (created1) delete arg1;
17746 }
17747 return resultobj;
17748 fail:
17749 {
17750 if (created1) delete arg1;
17751 }
17752 return NULL;
17753 }
17754
17755
17756 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj = 0;
17758 wxImage *arg1 = (wxImage *) 0 ;
17759 wxInputStream *arg2 = 0 ;
17760 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17761 int arg4 = (int) -1 ;
17762 bool result;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 wxPyInputStream *temp2 ;
17766 bool created2 ;
17767 long val3 ;
17768 int ecode3 = 0 ;
17769 int val4 ;
17770 int ecode4 = 0 ;
17771 PyObject * obj0 = 0 ;
17772 PyObject * obj1 = 0 ;
17773 PyObject * obj2 = 0 ;
17774 PyObject * obj3 = 0 ;
17775 char * kwnames[] = {
17776 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17777 };
17778
17779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17781 if (!SWIG_IsOK(res1)) {
17782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17783 }
17784 arg1 = reinterpret_cast< wxImage * >(argp1);
17785 {
17786 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17787 arg2 = temp2->m_wxis;
17788 created2 = false;
17789 } else {
17790 PyErr_Clear(); // clear the failure of the wxPyConvert above
17791 arg2 = wxPyCBInputStream_create(obj1, false);
17792 if (arg2 == NULL) {
17793 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17794 SWIG_fail;
17795 }
17796 created2 = true;
17797 }
17798 }
17799 if (obj2) {
17800 ecode3 = SWIG_AsVal_long(obj2, &val3);
17801 if (!SWIG_IsOK(ecode3)) {
17802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17803 }
17804 arg3 = static_cast< long >(val3);
17805 }
17806 if (obj3) {
17807 ecode4 = SWIG_AsVal_int(obj3, &val4);
17808 if (!SWIG_IsOK(ecode4)) {
17809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17810 }
17811 arg4 = static_cast< int >(val4);
17812 }
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17816 wxPyEndAllowThreads(__tstate);
17817 if (PyErr_Occurred()) SWIG_fail;
17818 }
17819 {
17820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17821 }
17822 {
17823 if (created2) delete arg2;
17824 }
17825 return resultobj;
17826 fail:
17827 {
17828 if (created2) delete arg2;
17829 }
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj = 0;
17836 wxImage *arg1 = (wxImage *) 0 ;
17837 wxInputStream *arg2 = 0 ;
17838 wxString *arg3 = 0 ;
17839 int arg4 = (int) -1 ;
17840 bool result;
17841 void *argp1 = 0 ;
17842 int res1 = 0 ;
17843 wxPyInputStream *temp2 ;
17844 bool created2 ;
17845 bool temp3 = false ;
17846 int val4 ;
17847 int ecode4 = 0 ;
17848 PyObject * obj0 = 0 ;
17849 PyObject * obj1 = 0 ;
17850 PyObject * obj2 = 0 ;
17851 PyObject * obj3 = 0 ;
17852 char * kwnames[] = {
17853 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17854 };
17855
17856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17860 }
17861 arg1 = reinterpret_cast< wxImage * >(argp1);
17862 {
17863 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17864 arg2 = temp2->m_wxis;
17865 created2 = false;
17866 } else {
17867 PyErr_Clear(); // clear the failure of the wxPyConvert above
17868 arg2 = wxPyCBInputStream_create(obj1, false);
17869 if (arg2 == NULL) {
17870 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17871 SWIG_fail;
17872 }
17873 created2 = true;
17874 }
17875 }
17876 {
17877 arg3 = wxString_in_helper(obj2);
17878 if (arg3 == NULL) SWIG_fail;
17879 temp3 = true;
17880 }
17881 if (obj3) {
17882 ecode4 = SWIG_AsVal_int(obj3, &val4);
17883 if (!SWIG_IsOK(ecode4)) {
17884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17885 }
17886 arg4 = static_cast< int >(val4);
17887 }
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 {
17895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17896 }
17897 {
17898 if (created2) delete arg2;
17899 }
17900 {
17901 if (temp3)
17902 delete arg3;
17903 }
17904 return resultobj;
17905 fail:
17906 {
17907 if (created2) delete arg2;
17908 }
17909 {
17910 if (temp3)
17911 delete arg3;
17912 }
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17918 PyObject *resultobj = 0;
17919 wxImage *arg1 = (wxImage *) 0 ;
17920 bool result;
17921 void *argp1 = 0 ;
17922 int res1 = 0 ;
17923 PyObject *swig_obj[1] ;
17924
17925 if (!args) SWIG_fail;
17926 swig_obj[0] = args;
17927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17930 }
17931 arg1 = reinterpret_cast< wxImage * >(argp1);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = (bool)(arg1)->IsOk();
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxImage *arg1 = (wxImage *) 0 ;
17950 int result;
17951 void *argp1 = 0 ;
17952 int res1 = 0 ;
17953 PyObject *swig_obj[1] ;
17954
17955 if (!args) SWIG_fail;
17956 swig_obj[0] = args;
17957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17958 if (!SWIG_IsOK(res1)) {
17959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17960 }
17961 arg1 = reinterpret_cast< wxImage * >(argp1);
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 result = (int)(arg1)->GetWidth();
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 resultobj = SWIG_From_int(static_cast< int >(result));
17969 return resultobj;
17970 fail:
17971 return NULL;
17972 }
17973
17974
17975 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17976 PyObject *resultobj = 0;
17977 wxImage *arg1 = (wxImage *) 0 ;
17978 int result;
17979 void *argp1 = 0 ;
17980 int res1 = 0 ;
17981 PyObject *swig_obj[1] ;
17982
17983 if (!args) SWIG_fail;
17984 swig_obj[0] = args;
17985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17986 if (!SWIG_IsOK(res1)) {
17987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17988 }
17989 arg1 = reinterpret_cast< wxImage * >(argp1);
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 result = (int)(arg1)->GetHeight();
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 resultobj = SWIG_From_int(static_cast< int >(result));
17997 return resultobj;
17998 fail:
17999 return NULL;
18000 }
18001
18002
18003 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18004 PyObject *resultobj = 0;
18005 wxImage *arg1 = (wxImage *) 0 ;
18006 wxSize result;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 PyObject *swig_obj[1] ;
18010
18011 if (!args) SWIG_fail;
18012 swig_obj[0] = args;
18013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18014 if (!SWIG_IsOK(res1)) {
18015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18016 }
18017 arg1 = reinterpret_cast< wxImage * >(argp1);
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = wxImage_GetSize(arg1);
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj = 0;
18033 wxImage *arg1 = (wxImage *) 0 ;
18034 wxRect *arg2 = 0 ;
18035 SwigValueWrapper<wxImage > result;
18036 void *argp1 = 0 ;
18037 int res1 = 0 ;
18038 wxRect temp2 ;
18039 PyObject * obj0 = 0 ;
18040 PyObject * obj1 = 0 ;
18041 char * kwnames[] = {
18042 (char *) "self",(char *) "rect", NULL
18043 };
18044
18045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18047 if (!SWIG_IsOK(res1)) {
18048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18049 }
18050 arg1 = reinterpret_cast< wxImage * >(argp1);
18051 {
18052 arg2 = &temp2;
18053 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18054 }
18055 {
18056 PyThreadState* __tstate = wxPyBeginAllowThreads();
18057 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18062 return resultobj;
18063 fail:
18064 return NULL;
18065 }
18066
18067
18068 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18069 PyObject *resultobj = 0;
18070 wxImage *arg1 = (wxImage *) 0 ;
18071 wxSize *arg2 = 0 ;
18072 wxPoint *arg3 = 0 ;
18073 int arg4 = (int) -1 ;
18074 int arg5 = (int) -1 ;
18075 int arg6 = (int) -1 ;
18076 SwigValueWrapper<wxImage > result;
18077 void *argp1 = 0 ;
18078 int res1 = 0 ;
18079 wxSize temp2 ;
18080 wxPoint temp3 ;
18081 int val4 ;
18082 int ecode4 = 0 ;
18083 int val5 ;
18084 int ecode5 = 0 ;
18085 int val6 ;
18086 int ecode6 = 0 ;
18087 PyObject * obj0 = 0 ;
18088 PyObject * obj1 = 0 ;
18089 PyObject * obj2 = 0 ;
18090 PyObject * obj3 = 0 ;
18091 PyObject * obj4 = 0 ;
18092 PyObject * obj5 = 0 ;
18093 char * kwnames[] = {
18094 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18095 };
18096
18097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18099 if (!SWIG_IsOK(res1)) {
18100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18101 }
18102 arg1 = reinterpret_cast< wxImage * >(argp1);
18103 {
18104 arg2 = &temp2;
18105 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18106 }
18107 {
18108 arg3 = &temp3;
18109 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18110 }
18111 if (obj3) {
18112 ecode4 = SWIG_AsVal_int(obj3, &val4);
18113 if (!SWIG_IsOK(ecode4)) {
18114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18115 }
18116 arg4 = static_cast< int >(val4);
18117 }
18118 if (obj4) {
18119 ecode5 = SWIG_AsVal_int(obj4, &val5);
18120 if (!SWIG_IsOK(ecode5)) {
18121 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18122 }
18123 arg5 = static_cast< int >(val5);
18124 }
18125 if (obj5) {
18126 ecode6 = SWIG_AsVal_int(obj5, &val6);
18127 if (!SWIG_IsOK(ecode6)) {
18128 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18129 }
18130 arg6 = static_cast< int >(val6);
18131 }
18132 {
18133 PyThreadState* __tstate = wxPyBeginAllowThreads();
18134 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18146 PyObject *resultobj = 0;
18147 wxImage *arg1 = (wxImage *) 0 ;
18148 SwigValueWrapper<wxImage > result;
18149 void *argp1 = 0 ;
18150 int res1 = 0 ;
18151 PyObject *swig_obj[1] ;
18152
18153 if (!args) SWIG_fail;
18154 swig_obj[0] = args;
18155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18156 if (!SWIG_IsOK(res1)) {
18157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18158 }
18159 arg1 = reinterpret_cast< wxImage * >(argp1);
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (arg1)->Copy();
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18167 return resultobj;
18168 fail:
18169 return NULL;
18170 }
18171
18172
18173 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18174 PyObject *resultobj = 0;
18175 wxImage *arg1 = (wxImage *) 0 ;
18176 wxImage *arg2 = 0 ;
18177 int arg3 ;
18178 int arg4 ;
18179 void *argp1 = 0 ;
18180 int res1 = 0 ;
18181 void *argp2 = 0 ;
18182 int res2 = 0 ;
18183 int val3 ;
18184 int ecode3 = 0 ;
18185 int val4 ;
18186 int ecode4 = 0 ;
18187 PyObject * obj0 = 0 ;
18188 PyObject * obj1 = 0 ;
18189 PyObject * obj2 = 0 ;
18190 PyObject * obj3 = 0 ;
18191 char * kwnames[] = {
18192 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18193 };
18194
18195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18197 if (!SWIG_IsOK(res1)) {
18198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18199 }
18200 arg1 = reinterpret_cast< wxImage * >(argp1);
18201 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18202 if (!SWIG_IsOK(res2)) {
18203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18204 }
18205 if (!argp2) {
18206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18207 }
18208 arg2 = reinterpret_cast< wxImage * >(argp2);
18209 ecode3 = SWIG_AsVal_int(obj2, &val3);
18210 if (!SWIG_IsOK(ecode3)) {
18211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18212 }
18213 arg3 = static_cast< int >(val3);
18214 ecode4 = SWIG_AsVal_int(obj3, &val4);
18215 if (!SWIG_IsOK(ecode4)) {
18216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18217 }
18218 arg4 = static_cast< int >(val4);
18219 {
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18222 wxPyEndAllowThreads(__tstate);
18223 if (PyErr_Occurred()) SWIG_fail;
18224 }
18225 resultobj = SWIG_Py_Void();
18226 return resultobj;
18227 fail:
18228 return NULL;
18229 }
18230
18231
18232 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18233 PyObject *resultobj = 0;
18234 wxImage *arg1 = (wxImage *) 0 ;
18235 PyObject *result = 0 ;
18236 void *argp1 = 0 ;
18237 int res1 = 0 ;
18238 PyObject *swig_obj[1] ;
18239
18240 if (!args) SWIG_fail;
18241 swig_obj[0] = args;
18242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18243 if (!SWIG_IsOK(res1)) {
18244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18245 }
18246 arg1 = reinterpret_cast< wxImage * >(argp1);
18247 {
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 result = (PyObject *)wxImage_GetData(arg1);
18250 wxPyEndAllowThreads(__tstate);
18251 if (PyErr_Occurred()) SWIG_fail;
18252 }
18253 resultobj = result;
18254 return resultobj;
18255 fail:
18256 return NULL;
18257 }
18258
18259
18260 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18261 PyObject *resultobj = 0;
18262 wxImage *arg1 = (wxImage *) 0 ;
18263 buffer arg2 ;
18264 int arg3 ;
18265 void *argp1 = 0 ;
18266 int res1 = 0 ;
18267 Py_ssize_t temp2 ;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char * kwnames[] = {
18271 (char *) "self",(char *) "data", NULL
18272 };
18273
18274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18276 if (!SWIG_IsOK(res1)) {
18277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18278 }
18279 arg1 = reinterpret_cast< wxImage * >(argp1);
18280 {
18281 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18282 arg3 = (int)temp2;
18283 }
18284 {
18285 PyThreadState* __tstate = wxPyBeginAllowThreads();
18286 wxImage_SetData(arg1,arg2,arg3);
18287 wxPyEndAllowThreads(__tstate);
18288 if (PyErr_Occurred()) SWIG_fail;
18289 }
18290 resultobj = SWIG_Py_Void();
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18298 PyObject *resultobj = 0;
18299 wxImage *arg1 = (wxImage *) 0 ;
18300 PyObject *result = 0 ;
18301 void *argp1 = 0 ;
18302 int res1 = 0 ;
18303 PyObject *swig_obj[1] ;
18304
18305 if (!args) SWIG_fail;
18306 swig_obj[0] = args;
18307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18308 if (!SWIG_IsOK(res1)) {
18309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18310 }
18311 arg1 = reinterpret_cast< wxImage * >(argp1);
18312 {
18313 PyThreadState* __tstate = wxPyBeginAllowThreads();
18314 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 resultobj = result;
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj = 0;
18327 wxImage *arg1 = (wxImage *) 0 ;
18328 buffer arg2 ;
18329 int arg3 ;
18330 void *argp1 = 0 ;
18331 int res1 = 0 ;
18332 Py_ssize_t temp2 ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 char * kwnames[] = {
18336 (char *) "self",(char *) "data", NULL
18337 };
18338
18339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18343 }
18344 arg1 = reinterpret_cast< wxImage * >(argp1);
18345 {
18346 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18347 arg3 = (int)temp2;
18348 }
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 wxImage_SetDataBuffer(arg1,arg2,arg3);
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_Py_Void();
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18363 PyObject *resultobj = 0;
18364 wxImage *arg1 = (wxImage *) 0 ;
18365 PyObject *result = 0 ;
18366 void *argp1 = 0 ;
18367 int res1 = 0 ;
18368 PyObject *swig_obj[1] ;
18369
18370 if (!args) SWIG_fail;
18371 swig_obj[0] = args;
18372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18373 if (!SWIG_IsOK(res1)) {
18374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18375 }
18376 arg1 = reinterpret_cast< wxImage * >(argp1);
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 result = (PyObject *)wxImage_GetAlphaData(arg1);
18380 wxPyEndAllowThreads(__tstate);
18381 if (PyErr_Occurred()) SWIG_fail;
18382 }
18383 resultobj = result;
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj = 0;
18392 wxImage *arg1 = (wxImage *) 0 ;
18393 buffer arg2 ;
18394 int arg3 ;
18395 void *argp1 = 0 ;
18396 int res1 = 0 ;
18397 Py_ssize_t temp2 ;
18398 PyObject * obj0 = 0 ;
18399 PyObject * obj1 = 0 ;
18400 char * kwnames[] = {
18401 (char *) "self",(char *) "alpha", NULL
18402 };
18403
18404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18406 if (!SWIG_IsOK(res1)) {
18407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18408 }
18409 arg1 = reinterpret_cast< wxImage * >(argp1);
18410 {
18411 if (obj1 != Py_None) {
18412 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18413 arg3 = (int)temp2;
18414 }
18415 }
18416 {
18417 PyThreadState* __tstate = wxPyBeginAllowThreads();
18418 wxImage_SetAlphaData(arg1,arg2,arg3);
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 resultobj = SWIG_Py_Void();
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18430 PyObject *resultobj = 0;
18431 wxImage *arg1 = (wxImage *) 0 ;
18432 PyObject *result = 0 ;
18433 void *argp1 = 0 ;
18434 int res1 = 0 ;
18435 PyObject *swig_obj[1] ;
18436
18437 if (!args) SWIG_fail;
18438 swig_obj[0] = args;
18439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18440 if (!SWIG_IsOK(res1)) {
18441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18442 }
18443 arg1 = reinterpret_cast< wxImage * >(argp1);
18444 {
18445 PyThreadState* __tstate = wxPyBeginAllowThreads();
18446 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18447 wxPyEndAllowThreads(__tstate);
18448 if (PyErr_Occurred()) SWIG_fail;
18449 }
18450 resultobj = result;
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj = 0;
18459 wxImage *arg1 = (wxImage *) 0 ;
18460 buffer arg2 ;
18461 int arg3 ;
18462 void *argp1 = 0 ;
18463 int res1 = 0 ;
18464 Py_ssize_t temp2 ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char * kwnames[] = {
18468 (char *) "self",(char *) "alpha", NULL
18469 };
18470
18471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18473 if (!SWIG_IsOK(res1)) {
18474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18475 }
18476 arg1 = reinterpret_cast< wxImage * >(argp1);
18477 {
18478 if (obj1 != Py_None) {
18479 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18480 arg3 = (int)temp2;
18481 }
18482 }
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 resultobj = SWIG_Py_Void();
18490 return resultobj;
18491 fail:
18492 return NULL;
18493 }
18494
18495
18496 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18497 PyObject *resultobj = 0;
18498 wxImage *arg1 = (wxImage *) 0 ;
18499 byte arg2 ;
18500 byte arg3 ;
18501 byte arg4 ;
18502 void *argp1 = 0 ;
18503 int res1 = 0 ;
18504 unsigned char val2 ;
18505 int ecode2 = 0 ;
18506 unsigned char val3 ;
18507 int ecode3 = 0 ;
18508 unsigned char val4 ;
18509 int ecode4 = 0 ;
18510 PyObject * obj0 = 0 ;
18511 PyObject * obj1 = 0 ;
18512 PyObject * obj2 = 0 ;
18513 PyObject * obj3 = 0 ;
18514 char * kwnames[] = {
18515 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18516 };
18517
18518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18520 if (!SWIG_IsOK(res1)) {
18521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18522 }
18523 arg1 = reinterpret_cast< wxImage * >(argp1);
18524 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18525 if (!SWIG_IsOK(ecode2)) {
18526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18527 }
18528 arg2 = static_cast< byte >(val2);
18529 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18530 if (!SWIG_IsOK(ecode3)) {
18531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18532 }
18533 arg3 = static_cast< byte >(val3);
18534 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18535 if (!SWIG_IsOK(ecode4)) {
18536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18537 }
18538 arg4 = static_cast< byte >(val4);
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 (arg1)->SetMaskColour(arg2,arg3,arg4);
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 resultobj = SWIG_Py_Void();
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18553 PyObject *resultobj = 0;
18554 wxImage *arg1 = (wxImage *) 0 ;
18555 byte *arg2 = (byte *) 0 ;
18556 byte *arg3 = (byte *) 0 ;
18557 byte *arg4 = (byte *) 0 ;
18558 void *argp1 = 0 ;
18559 int res1 = 0 ;
18560 byte temp2 ;
18561 int res2 = SWIG_TMPOBJ ;
18562 byte temp3 ;
18563 int res3 = SWIG_TMPOBJ ;
18564 byte temp4 ;
18565 int res4 = SWIG_TMPOBJ ;
18566 PyObject *swig_obj[1] ;
18567
18568 arg2 = &temp2;
18569 arg3 = &temp3;
18570 arg4 = &temp4;
18571 if (!args) SWIG_fail;
18572 swig_obj[0] = args;
18573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18574 if (!SWIG_IsOK(res1)) {
18575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18576 }
18577 arg1 = reinterpret_cast< wxImage * >(argp1);
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18581 wxPyEndAllowThreads(__tstate);
18582 if (PyErr_Occurred()) SWIG_fail;
18583 }
18584 resultobj = SWIG_Py_Void();
18585 if (SWIG_IsTmpObj(res2)) {
18586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18587 } else {
18588 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18590 }
18591 if (SWIG_IsTmpObj(res3)) {
18592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18593 } else {
18594 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18596 }
18597 if (SWIG_IsTmpObj(res4)) {
18598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18599 } else {
18600 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18602 }
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18610 PyObject *resultobj = 0;
18611 wxImage *arg1 = (wxImage *) 0 ;
18612 byte result;
18613 void *argp1 = 0 ;
18614 int res1 = 0 ;
18615 PyObject *swig_obj[1] ;
18616
18617 if (!args) SWIG_fail;
18618 swig_obj[0] = args;
18619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18620 if (!SWIG_IsOK(res1)) {
18621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18622 }
18623 arg1 = reinterpret_cast< wxImage * >(argp1);
18624 {
18625 PyThreadState* __tstate = wxPyBeginAllowThreads();
18626 result = (byte)(arg1)->GetMaskRed();
18627 wxPyEndAllowThreads(__tstate);
18628 if (PyErr_Occurred()) SWIG_fail;
18629 }
18630 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18631 return resultobj;
18632 fail:
18633 return NULL;
18634 }
18635
18636
18637 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18638 PyObject *resultobj = 0;
18639 wxImage *arg1 = (wxImage *) 0 ;
18640 byte result;
18641 void *argp1 = 0 ;
18642 int res1 = 0 ;
18643 PyObject *swig_obj[1] ;
18644
18645 if (!args) SWIG_fail;
18646 swig_obj[0] = args;
18647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18648 if (!SWIG_IsOK(res1)) {
18649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18650 }
18651 arg1 = reinterpret_cast< wxImage * >(argp1);
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 result = (byte)(arg1)->GetMaskGreen();
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18666 PyObject *resultobj = 0;
18667 wxImage *arg1 = (wxImage *) 0 ;
18668 byte result;
18669 void *argp1 = 0 ;
18670 int res1 = 0 ;
18671 PyObject *swig_obj[1] ;
18672
18673 if (!args) SWIG_fail;
18674 swig_obj[0] = args;
18675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18676 if (!SWIG_IsOK(res1)) {
18677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18678 }
18679 arg1 = reinterpret_cast< wxImage * >(argp1);
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 result = (byte)(arg1)->GetMaskBlue();
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18694 PyObject *resultobj = 0;
18695 wxImage *arg1 = (wxImage *) 0 ;
18696 bool arg2 = (bool) true ;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 bool val2 ;
18700 int ecode2 = 0 ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char * kwnames[] = {
18704 (char *) "self",(char *) "mask", NULL
18705 };
18706
18707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18709 if (!SWIG_IsOK(res1)) {
18710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18711 }
18712 arg1 = reinterpret_cast< wxImage * >(argp1);
18713 if (obj1) {
18714 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18715 if (!SWIG_IsOK(ecode2)) {
18716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18717 }
18718 arg2 = static_cast< bool >(val2);
18719 }
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 (arg1)->SetMask(arg2);
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 resultobj = SWIG_Py_Void();
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18734 PyObject *resultobj = 0;
18735 wxImage *arg1 = (wxImage *) 0 ;
18736 bool result;
18737 void *argp1 = 0 ;
18738 int res1 = 0 ;
18739 PyObject *swig_obj[1] ;
18740
18741 if (!args) SWIG_fail;
18742 swig_obj[0] = args;
18743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18744 if (!SWIG_IsOK(res1)) {
18745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18746 }
18747 arg1 = reinterpret_cast< wxImage * >(argp1);
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = (bool)(arg1)->HasMask();
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 {
18755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18756 }
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18764 PyObject *resultobj = 0;
18765 wxImage *arg1 = (wxImage *) 0 ;
18766 double arg2 ;
18767 wxPoint *arg3 = 0 ;
18768 bool arg4 = (bool) true ;
18769 wxPoint *arg5 = (wxPoint *) NULL ;
18770 SwigValueWrapper<wxImage > result;
18771 void *argp1 = 0 ;
18772 int res1 = 0 ;
18773 double val2 ;
18774 int ecode2 = 0 ;
18775 wxPoint temp3 ;
18776 bool val4 ;
18777 int ecode4 = 0 ;
18778 void *argp5 = 0 ;
18779 int res5 = 0 ;
18780 PyObject * obj0 = 0 ;
18781 PyObject * obj1 = 0 ;
18782 PyObject * obj2 = 0 ;
18783 PyObject * obj3 = 0 ;
18784 PyObject * obj4 = 0 ;
18785 char * kwnames[] = {
18786 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18787 };
18788
18789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18791 if (!SWIG_IsOK(res1)) {
18792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18793 }
18794 arg1 = reinterpret_cast< wxImage * >(argp1);
18795 ecode2 = SWIG_AsVal_double(obj1, &val2);
18796 if (!SWIG_IsOK(ecode2)) {
18797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18798 }
18799 arg2 = static_cast< double >(val2);
18800 {
18801 arg3 = &temp3;
18802 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18803 }
18804 if (obj3) {
18805 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18806 if (!SWIG_IsOK(ecode4)) {
18807 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18808 }
18809 arg4 = static_cast< bool >(val4);
18810 }
18811 if (obj4) {
18812 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18813 if (!SWIG_IsOK(res5)) {
18814 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18815 }
18816 arg5 = reinterpret_cast< wxPoint * >(argp5);
18817 }
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj = 0;
18833 wxImage *arg1 = (wxImage *) 0 ;
18834 bool arg2 = (bool) true ;
18835 SwigValueWrapper<wxImage > result;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 bool val2 ;
18839 int ecode2 = 0 ;
18840 PyObject * obj0 = 0 ;
18841 PyObject * obj1 = 0 ;
18842 char * kwnames[] = {
18843 (char *) "self",(char *) "clockwise", NULL
18844 };
18845
18846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18848 if (!SWIG_IsOK(res1)) {
18849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18850 }
18851 arg1 = reinterpret_cast< wxImage * >(argp1);
18852 if (obj1) {
18853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18854 if (!SWIG_IsOK(ecode2)) {
18855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18856 }
18857 arg2 = static_cast< bool >(val2);
18858 }
18859 {
18860 PyThreadState* __tstate = wxPyBeginAllowThreads();
18861 result = (arg1)->Rotate90(arg2);
18862 wxPyEndAllowThreads(__tstate);
18863 if (PyErr_Occurred()) SWIG_fail;
18864 }
18865 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj = 0;
18874 wxImage *arg1 = (wxImage *) 0 ;
18875 bool arg2 = (bool) true ;
18876 SwigValueWrapper<wxImage > result;
18877 void *argp1 = 0 ;
18878 int res1 = 0 ;
18879 bool val2 ;
18880 int ecode2 = 0 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char * kwnames[] = {
18884 (char *) "self",(char *) "horizontally", NULL
18885 };
18886
18887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18889 if (!SWIG_IsOK(res1)) {
18890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18891 }
18892 arg1 = reinterpret_cast< wxImage * >(argp1);
18893 if (obj1) {
18894 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18895 if (!SWIG_IsOK(ecode2)) {
18896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18897 }
18898 arg2 = static_cast< bool >(val2);
18899 }
18900 {
18901 PyThreadState* __tstate = wxPyBeginAllowThreads();
18902 result = (arg1)->Mirror(arg2);
18903 wxPyEndAllowThreads(__tstate);
18904 if (PyErr_Occurred()) SWIG_fail;
18905 }
18906 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18907 return resultobj;
18908 fail:
18909 return NULL;
18910 }
18911
18912
18913 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18914 PyObject *resultobj = 0;
18915 wxImage *arg1 = (wxImage *) 0 ;
18916 byte arg2 ;
18917 byte arg3 ;
18918 byte arg4 ;
18919 byte arg5 ;
18920 byte arg6 ;
18921 byte arg7 ;
18922 void *argp1 = 0 ;
18923 int res1 = 0 ;
18924 unsigned char val2 ;
18925 int ecode2 = 0 ;
18926 unsigned char val3 ;
18927 int ecode3 = 0 ;
18928 unsigned char val4 ;
18929 int ecode4 = 0 ;
18930 unsigned char val5 ;
18931 int ecode5 = 0 ;
18932 unsigned char val6 ;
18933 int ecode6 = 0 ;
18934 unsigned char val7 ;
18935 int ecode7 = 0 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 PyObject * obj2 = 0 ;
18939 PyObject * obj3 = 0 ;
18940 PyObject * obj4 = 0 ;
18941 PyObject * obj5 = 0 ;
18942 PyObject * obj6 = 0 ;
18943 char * kwnames[] = {
18944 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18945 };
18946
18947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18949 if (!SWIG_IsOK(res1)) {
18950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18951 }
18952 arg1 = reinterpret_cast< wxImage * >(argp1);
18953 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18954 if (!SWIG_IsOK(ecode2)) {
18955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18956 }
18957 arg2 = static_cast< byte >(val2);
18958 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18959 if (!SWIG_IsOK(ecode3)) {
18960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18961 }
18962 arg3 = static_cast< byte >(val3);
18963 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18964 if (!SWIG_IsOK(ecode4)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18966 }
18967 arg4 = static_cast< byte >(val4);
18968 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18969 if (!SWIG_IsOK(ecode5)) {
18970 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18971 }
18972 arg5 = static_cast< byte >(val5);
18973 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18974 if (!SWIG_IsOK(ecode6)) {
18975 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18976 }
18977 arg6 = static_cast< byte >(val6);
18978 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18979 if (!SWIG_IsOK(ecode7)) {
18980 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18981 }
18982 arg7 = static_cast< byte >(val7);
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 resultobj = SWIG_Py_Void();
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18997 PyObject *resultobj = 0;
18998 wxImage *arg1 = (wxImage *) 0 ;
18999 double arg2 = (double) 0.299 ;
19000 double arg3 = (double) 0.587 ;
19001 double arg4 = (double) 0.114 ;
19002 SwigValueWrapper<wxImage > result;
19003 void *argp1 = 0 ;
19004 int res1 = 0 ;
19005 double val2 ;
19006 int ecode2 = 0 ;
19007 double val3 ;
19008 int ecode3 = 0 ;
19009 double val4 ;
19010 int ecode4 = 0 ;
19011 PyObject * obj0 = 0 ;
19012 PyObject * obj1 = 0 ;
19013 PyObject * obj2 = 0 ;
19014 PyObject * obj3 = 0 ;
19015 char * kwnames[] = {
19016 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19017 };
19018
19019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19021 if (!SWIG_IsOK(res1)) {
19022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19023 }
19024 arg1 = reinterpret_cast< wxImage * >(argp1);
19025 if (obj1) {
19026 ecode2 = SWIG_AsVal_double(obj1, &val2);
19027 if (!SWIG_IsOK(ecode2)) {
19028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19029 }
19030 arg2 = static_cast< double >(val2);
19031 }
19032 if (obj2) {
19033 ecode3 = SWIG_AsVal_double(obj2, &val3);
19034 if (!SWIG_IsOK(ecode3)) {
19035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19036 }
19037 arg3 = static_cast< double >(val3);
19038 }
19039 if (obj3) {
19040 ecode4 = SWIG_AsVal_double(obj3, &val4);
19041 if (!SWIG_IsOK(ecode4)) {
19042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19043 }
19044 arg4 = static_cast< double >(val4);
19045 }
19046 {
19047 PyThreadState* __tstate = wxPyBeginAllowThreads();
19048 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj = 0;
19061 wxImage *arg1 = (wxImage *) 0 ;
19062 byte arg2 ;
19063 byte arg3 ;
19064 byte arg4 ;
19065 SwigValueWrapper<wxImage > result;
19066 void *argp1 = 0 ;
19067 int res1 = 0 ;
19068 unsigned char val2 ;
19069 int ecode2 = 0 ;
19070 unsigned char val3 ;
19071 int ecode3 = 0 ;
19072 unsigned char val4 ;
19073 int ecode4 = 0 ;
19074 PyObject * obj0 = 0 ;
19075 PyObject * obj1 = 0 ;
19076 PyObject * obj2 = 0 ;
19077 PyObject * obj3 = 0 ;
19078 char * kwnames[] = {
19079 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19080 };
19081
19082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19084 if (!SWIG_IsOK(res1)) {
19085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19086 }
19087 arg1 = reinterpret_cast< wxImage * >(argp1);
19088 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19089 if (!SWIG_IsOK(ecode2)) {
19090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19091 }
19092 arg2 = static_cast< byte >(val2);
19093 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19094 if (!SWIG_IsOK(ecode3)) {
19095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19096 }
19097 arg3 = static_cast< byte >(val3);
19098 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19099 if (!SWIG_IsOK(ecode4)) {
19100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19101 }
19102 arg4 = static_cast< byte >(val4);
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19117 PyObject *resultobj = 0;
19118 wxImage *arg1 = (wxImage *) 0 ;
19119 wxString *arg2 = 0 ;
19120 wxString *arg3 = 0 ;
19121 void *argp1 = 0 ;
19122 int res1 = 0 ;
19123 bool temp2 = false ;
19124 bool temp3 = false ;
19125 PyObject * obj0 = 0 ;
19126 PyObject * obj1 = 0 ;
19127 PyObject * obj2 = 0 ;
19128 char * kwnames[] = {
19129 (char *) "self",(char *) "name",(char *) "value", NULL
19130 };
19131
19132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19134 if (!SWIG_IsOK(res1)) {
19135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19136 }
19137 arg1 = reinterpret_cast< wxImage * >(argp1);
19138 {
19139 arg2 = wxString_in_helper(obj1);
19140 if (arg2 == NULL) SWIG_fail;
19141 temp2 = true;
19142 }
19143 {
19144 arg3 = wxString_in_helper(obj2);
19145 if (arg3 == NULL) SWIG_fail;
19146 temp3 = true;
19147 }
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 resultobj = SWIG_Py_Void();
19155 {
19156 if (temp2)
19157 delete arg2;
19158 }
19159 {
19160 if (temp3)
19161 delete arg3;
19162 }
19163 return resultobj;
19164 fail:
19165 {
19166 if (temp2)
19167 delete arg2;
19168 }
19169 {
19170 if (temp3)
19171 delete arg3;
19172 }
19173 return NULL;
19174 }
19175
19176
19177 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19178 PyObject *resultobj = 0;
19179 wxImage *arg1 = (wxImage *) 0 ;
19180 wxString *arg2 = 0 ;
19181 int arg3 ;
19182 void *argp1 = 0 ;
19183 int res1 = 0 ;
19184 bool temp2 = false ;
19185 int val3 ;
19186 int ecode3 = 0 ;
19187 PyObject * obj0 = 0 ;
19188 PyObject * obj1 = 0 ;
19189 PyObject * obj2 = 0 ;
19190 char * kwnames[] = {
19191 (char *) "self",(char *) "name",(char *) "value", NULL
19192 };
19193
19194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19196 if (!SWIG_IsOK(res1)) {
19197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19198 }
19199 arg1 = reinterpret_cast< wxImage * >(argp1);
19200 {
19201 arg2 = wxString_in_helper(obj1);
19202 if (arg2 == NULL) SWIG_fail;
19203 temp2 = true;
19204 }
19205 ecode3 = SWIG_AsVal_int(obj2, &val3);
19206 if (!SWIG_IsOK(ecode3)) {
19207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19208 }
19209 arg3 = static_cast< int >(val3);
19210 {
19211 PyThreadState* __tstate = wxPyBeginAllowThreads();
19212 (arg1)->SetOption((wxString const &)*arg2,arg3);
19213 wxPyEndAllowThreads(__tstate);
19214 if (PyErr_Occurred()) SWIG_fail;
19215 }
19216 resultobj = SWIG_Py_Void();
19217 {
19218 if (temp2)
19219 delete arg2;
19220 }
19221 return resultobj;
19222 fail:
19223 {
19224 if (temp2)
19225 delete arg2;
19226 }
19227 return NULL;
19228 }
19229
19230
19231 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19232 PyObject *resultobj = 0;
19233 wxImage *arg1 = (wxImage *) 0 ;
19234 wxString *arg2 = 0 ;
19235 wxString result;
19236 void *argp1 = 0 ;
19237 int res1 = 0 ;
19238 bool temp2 = false ;
19239 PyObject * obj0 = 0 ;
19240 PyObject * obj1 = 0 ;
19241 char * kwnames[] = {
19242 (char *) "self",(char *) "name", NULL
19243 };
19244
19245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19247 if (!SWIG_IsOK(res1)) {
19248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19249 }
19250 arg1 = reinterpret_cast< wxImage * >(argp1);
19251 {
19252 arg2 = wxString_in_helper(obj1);
19253 if (arg2 == NULL) SWIG_fail;
19254 temp2 = true;
19255 }
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 {
19263 #if wxUSE_UNICODE
19264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19265 #else
19266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19267 #endif
19268 }
19269 {
19270 if (temp2)
19271 delete arg2;
19272 }
19273 return resultobj;
19274 fail:
19275 {
19276 if (temp2)
19277 delete arg2;
19278 }
19279 return NULL;
19280 }
19281
19282
19283 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19284 PyObject *resultobj = 0;
19285 wxImage *arg1 = (wxImage *) 0 ;
19286 wxString *arg2 = 0 ;
19287 int result;
19288 void *argp1 = 0 ;
19289 int res1 = 0 ;
19290 bool temp2 = false ;
19291 PyObject * obj0 = 0 ;
19292 PyObject * obj1 = 0 ;
19293 char * kwnames[] = {
19294 (char *) "self",(char *) "name", NULL
19295 };
19296
19297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19299 if (!SWIG_IsOK(res1)) {
19300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19301 }
19302 arg1 = reinterpret_cast< wxImage * >(argp1);
19303 {
19304 arg2 = wxString_in_helper(obj1);
19305 if (arg2 == NULL) SWIG_fail;
19306 temp2 = true;
19307 }
19308 {
19309 PyThreadState* __tstate = wxPyBeginAllowThreads();
19310 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 resultobj = SWIG_From_int(static_cast< int >(result));
19315 {
19316 if (temp2)
19317 delete arg2;
19318 }
19319 return resultobj;
19320 fail:
19321 {
19322 if (temp2)
19323 delete arg2;
19324 }
19325 return NULL;
19326 }
19327
19328
19329 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj = 0;
19331 wxImage *arg1 = (wxImage *) 0 ;
19332 wxString *arg2 = 0 ;
19333 bool result;
19334 void *argp1 = 0 ;
19335 int res1 = 0 ;
19336 bool temp2 = false ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char * kwnames[] = {
19340 (char *) "self",(char *) "name", NULL
19341 };
19342
19343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19345 if (!SWIG_IsOK(res1)) {
19346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19347 }
19348 arg1 = reinterpret_cast< wxImage * >(argp1);
19349 {
19350 arg2 = wxString_in_helper(obj1);
19351 if (arg2 == NULL) SWIG_fail;
19352 temp2 = true;
19353 }
19354 {
19355 PyThreadState* __tstate = wxPyBeginAllowThreads();
19356 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19357 wxPyEndAllowThreads(__tstate);
19358 if (PyErr_Occurred()) SWIG_fail;
19359 }
19360 {
19361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19362 }
19363 {
19364 if (temp2)
19365 delete arg2;
19366 }
19367 return resultobj;
19368 fail:
19369 {
19370 if (temp2)
19371 delete arg2;
19372 }
19373 return NULL;
19374 }
19375
19376
19377 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19378 PyObject *resultobj = 0;
19379 wxImage *arg1 = (wxImage *) 0 ;
19380 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19381 unsigned long result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 unsigned long val2 ;
19385 int ecode2 = 0 ;
19386 PyObject * obj0 = 0 ;
19387 PyObject * obj1 = 0 ;
19388 char * kwnames[] = {
19389 (char *) "self",(char *) "stopafter", NULL
19390 };
19391
19392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19394 if (!SWIG_IsOK(res1)) {
19395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19396 }
19397 arg1 = reinterpret_cast< wxImage * >(argp1);
19398 if (obj1) {
19399 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19400 if (!SWIG_IsOK(ecode2)) {
19401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19402 }
19403 arg2 = static_cast< unsigned long >(val2);
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (unsigned long)(arg1)->CountColours(arg2);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxImage *arg1 = (wxImage *) 0 ;
19421 wxImageHistogram *arg2 = 0 ;
19422 unsigned long result;
19423 void *argp1 = 0 ;
19424 int res1 = 0 ;
19425 void *argp2 = 0 ;
19426 int res2 = 0 ;
19427 PyObject * obj0 = 0 ;
19428 PyObject * obj1 = 0 ;
19429 char * kwnames[] = {
19430 (char *) "self",(char *) "h", NULL
19431 };
19432
19433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19435 if (!SWIG_IsOK(res1)) {
19436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19437 }
19438 arg1 = reinterpret_cast< wxImage * >(argp1);
19439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19440 if (!SWIG_IsOK(res2)) {
19441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19442 }
19443 if (!argp2) {
19444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19445 }
19446 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19447 {
19448 PyThreadState* __tstate = wxPyBeginAllowThreads();
19449 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19450 wxPyEndAllowThreads(__tstate);
19451 if (PyErr_Occurred()) SWIG_fail;
19452 }
19453 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj = 0;
19462 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19463 void *argp1 = 0 ;
19464 int res1 = 0 ;
19465 PyObject * obj0 = 0 ;
19466 char * kwnames[] = {
19467 (char *) "handler", NULL
19468 };
19469
19470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19472 if (!SWIG_IsOK(res1)) {
19473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19474 }
19475 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 wxImage::AddHandler(arg1);
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = SWIG_Py_Void();
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19490 PyObject *resultobj = 0;
19491 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19492 void *argp1 = 0 ;
19493 int res1 = 0 ;
19494 PyObject * obj0 = 0 ;
19495 char * kwnames[] = {
19496 (char *) "handler", NULL
19497 };
19498
19499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19501 if (!SWIG_IsOK(res1)) {
19502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19503 }
19504 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 wxImage::InsertHandler(arg1);
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_Py_Void();
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj = 0;
19520 wxString *arg1 = 0 ;
19521 bool result;
19522 bool temp1 = false ;
19523 PyObject * obj0 = 0 ;
19524 char * kwnames[] = {
19525 (char *) "name", NULL
19526 };
19527
19528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19529 {
19530 arg1 = wxString_in_helper(obj0);
19531 if (arg1 == NULL) SWIG_fail;
19532 temp1 = true;
19533 }
19534 {
19535 PyThreadState* __tstate = wxPyBeginAllowThreads();
19536 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19537 wxPyEndAllowThreads(__tstate);
19538 if (PyErr_Occurred()) SWIG_fail;
19539 }
19540 {
19541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19542 }
19543 {
19544 if (temp1)
19545 delete arg1;
19546 }
19547 return resultobj;
19548 fail:
19549 {
19550 if (temp1)
19551 delete arg1;
19552 }
19553 return NULL;
19554 }
19555
19556
19557 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19558 PyObject *resultobj = 0;
19559 PyObject *result = 0 ;
19560
19561 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 result = (PyObject *)wxImage_GetHandlers();
19565 wxPyEndAllowThreads(__tstate);
19566 if (PyErr_Occurred()) SWIG_fail;
19567 }
19568 resultobj = result;
19569 return resultobj;
19570 fail:
19571 return NULL;
19572 }
19573
19574
19575 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19576 PyObject *resultobj = 0;
19577 wxString result;
19578
19579 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19580 {
19581 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = wxImage::GetImageExtWildcard();
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 {
19587 #if wxUSE_UNICODE
19588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19589 #else
19590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19591 #endif
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj = 0;
19601 wxImage *arg1 = (wxImage *) 0 ;
19602 int arg2 = (int) -1 ;
19603 wxBitmap result;
19604 void *argp1 = 0 ;
19605 int res1 = 0 ;
19606 int val2 ;
19607 int ecode2 = 0 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char * kwnames[] = {
19611 (char *) "self",(char *) "depth", NULL
19612 };
19613
19614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19616 if (!SWIG_IsOK(res1)) {
19617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19618 }
19619 arg1 = reinterpret_cast< wxImage * >(argp1);
19620 if (obj1) {
19621 ecode2 = SWIG_AsVal_int(obj1, &val2);
19622 if (!SWIG_IsOK(ecode2)) {
19623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19624 }
19625 arg2 = static_cast< int >(val2);
19626 }
19627 {
19628 if (!wxPyCheckForApp()) SWIG_fail;
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = wxImage_ConvertToBitmap(arg1,arg2);
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj = 0;
19643 wxImage *arg1 = (wxImage *) 0 ;
19644 byte arg2 ;
19645 byte arg3 ;
19646 byte arg4 ;
19647 wxBitmap result;
19648 void *argp1 = 0 ;
19649 int res1 = 0 ;
19650 unsigned char val2 ;
19651 int ecode2 = 0 ;
19652 unsigned char val3 ;
19653 int ecode3 = 0 ;
19654 unsigned char val4 ;
19655 int ecode4 = 0 ;
19656 PyObject * obj0 = 0 ;
19657 PyObject * obj1 = 0 ;
19658 PyObject * obj2 = 0 ;
19659 PyObject * obj3 = 0 ;
19660 char * kwnames[] = {
19661 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19662 };
19663
19664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19666 if (!SWIG_IsOK(res1)) {
19667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19668 }
19669 arg1 = reinterpret_cast< wxImage * >(argp1);
19670 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19671 if (!SWIG_IsOK(ecode2)) {
19672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19673 }
19674 arg2 = static_cast< byte >(val2);
19675 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19676 if (!SWIG_IsOK(ecode3)) {
19677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19678 }
19679 arg3 = static_cast< byte >(val3);
19680 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19681 if (!SWIG_IsOK(ecode4)) {
19682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19683 }
19684 arg4 = static_cast< byte >(val4);
19685 {
19686 if (!wxPyCheckForApp()) SWIG_fail;
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19693 return resultobj;
19694 fail:
19695 return NULL;
19696 }
19697
19698
19699 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19700 PyObject *resultobj = 0;
19701 wxImage *arg1 = (wxImage *) 0 ;
19702 double arg2 ;
19703 void *argp1 = 0 ;
19704 int res1 = 0 ;
19705 double val2 ;
19706 int ecode2 = 0 ;
19707 PyObject * obj0 = 0 ;
19708 PyObject * obj1 = 0 ;
19709 char * kwnames[] = {
19710 (char *) "self",(char *) "angle", NULL
19711 };
19712
19713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19715 if (!SWIG_IsOK(res1)) {
19716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19717 }
19718 arg1 = reinterpret_cast< wxImage * >(argp1);
19719 ecode2 = SWIG_AsVal_double(obj1, &val2);
19720 if (!SWIG_IsOK(ecode2)) {
19721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19722 }
19723 arg2 = static_cast< double >(val2);
19724 {
19725 PyThreadState* __tstate = wxPyBeginAllowThreads();
19726 (arg1)->RotateHue(arg2);
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 resultobj = SWIG_Py_Void();
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj = 0;
19739 wxImage_RGBValue arg1 ;
19740 wxImage_HSVValue result;
19741 void *argp1 ;
19742 int res1 = 0 ;
19743 PyObject * obj0 = 0 ;
19744 char * kwnames[] = {
19745 (char *) "rgb", NULL
19746 };
19747
19748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19749 {
19750 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19751 if (!SWIG_IsOK(res1)) {
19752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19753 }
19754 if (!argp1) {
19755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19756 } else {
19757 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19758 arg1 = *temp;
19759 if (SWIG_IsNewObj(res1)) delete temp;
19760 }
19761 }
19762 {
19763 PyThreadState* __tstate = wxPyBeginAllowThreads();
19764 result = wxImage::RGBtoHSV(arg1);
19765 wxPyEndAllowThreads(__tstate);
19766 if (PyErr_Occurred()) SWIG_fail;
19767 }
19768 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj = 0;
19777 wxImage_HSVValue arg1 ;
19778 wxImage_RGBValue result;
19779 void *argp1 ;
19780 int res1 = 0 ;
19781 PyObject * obj0 = 0 ;
19782 char * kwnames[] = {
19783 (char *) "hsv", NULL
19784 };
19785
19786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19787 {
19788 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19789 if (!SWIG_IsOK(res1)) {
19790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19791 }
19792 if (!argp1) {
19793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19794 } else {
19795 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19796 arg1 = *temp;
19797 if (SWIG_IsNewObj(res1)) delete temp;
19798 }
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = wxImage::HSVtoRGB(arg1);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19814 PyObject *obj;
19815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19816 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19817 return SWIG_Py_Void();
19818 }
19819
19820 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19821 return SWIG_Python_InitShadowInstance(args);
19822 }
19823
19824 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj = 0;
19826 int arg1 ;
19827 int arg2 ;
19828 buffer arg3 ;
19829 int arg4 ;
19830 buffer arg5 = (buffer) NULL ;
19831 int arg6 = (int) 0 ;
19832 wxImage *result = 0 ;
19833 int val1 ;
19834 int ecode1 = 0 ;
19835 int val2 ;
19836 int ecode2 = 0 ;
19837 Py_ssize_t temp3 ;
19838 Py_ssize_t temp5 ;
19839 PyObject * obj0 = 0 ;
19840 PyObject * obj1 = 0 ;
19841 PyObject * obj2 = 0 ;
19842 PyObject * obj3 = 0 ;
19843 char * kwnames[] = {
19844 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19845 };
19846
19847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19848 ecode1 = SWIG_AsVal_int(obj0, &val1);
19849 if (!SWIG_IsOK(ecode1)) {
19850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19851 }
19852 arg1 = static_cast< int >(val1);
19853 ecode2 = SWIG_AsVal_int(obj1, &val2);
19854 if (!SWIG_IsOK(ecode2)) {
19855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19856 }
19857 arg2 = static_cast< int >(val2);
19858 {
19859 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19860 arg4 = (int)temp3;
19861 }
19862 if (obj3) {
19863 {
19864 if (obj3 != Py_None) {
19865 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19866 arg6 = (int)temp5;
19867 }
19868 }
19869 }
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 {
19877 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19878 }
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 SWIGINTERN int NullImage_set(PyObject *) {
19886 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19887 return 1;
19888 }
19889
19890
19891 SWIGINTERN PyObject *NullImage_get(void) {
19892 PyObject *pyobj = 0;
19893
19894 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19895 return pyobj;
19896 }
19897
19898
19899 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19900 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19901 return 1;
19902 }
19903
19904
19905 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19906 PyObject *pyobj = 0;
19907
19908 {
19909 #if wxUSE_UNICODE
19910 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19911 #else
19912 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19913 #endif
19914 }
19915 return pyobj;
19916 }
19917
19918
19919 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19920 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19921 return 1;
19922 }
19923
19924
19925 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19926 PyObject *pyobj = 0;
19927
19928 {
19929 #if wxUSE_UNICODE
19930 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19931 #else
19932 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19933 #endif
19934 }
19935 return pyobj;
19936 }
19937
19938
19939 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19940 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19941 return 1;
19942 }
19943
19944
19945 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19946 PyObject *pyobj = 0;
19947
19948 {
19949 #if wxUSE_UNICODE
19950 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19951 #else
19952 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19953 #endif
19954 }
19955 return pyobj;
19956 }
19957
19958
19959 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19960 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19961 return 1;
19962 }
19963
19964
19965 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19966 PyObject *pyobj = 0;
19967
19968 {
19969 #if wxUSE_UNICODE
19970 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19971 #else
19972 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19973 #endif
19974 }
19975 return pyobj;
19976 }
19977
19978
19979 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19980 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19981 return 1;
19982 }
19983
19984
19985 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19986 PyObject *pyobj = 0;
19987
19988 {
19989 #if wxUSE_UNICODE
19990 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19991 #else
19992 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19993 #endif
19994 }
19995 return pyobj;
19996 }
19997
19998
19999 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20000 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20001 return 1;
20002 }
20003
20004
20005 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20006 PyObject *pyobj = 0;
20007
20008 {
20009 #if wxUSE_UNICODE
20010 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20011 #else
20012 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20013 #endif
20014 }
20015 return pyobj;
20016 }
20017
20018
20019 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20020 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20021 return 1;
20022 }
20023
20024
20025 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20026 PyObject *pyobj = 0;
20027
20028 {
20029 #if wxUSE_UNICODE
20030 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20031 #else
20032 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20033 #endif
20034 }
20035 return pyobj;
20036 }
20037
20038
20039 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20040 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20041 return 1;
20042 }
20043
20044
20045 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20046 PyObject *pyobj = 0;
20047
20048 {
20049 #if wxUSE_UNICODE
20050 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20051 #else
20052 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20053 #endif
20054 }
20055 return pyobj;
20056 }
20057
20058
20059 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20060 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20061 return 1;
20062 }
20063
20064
20065 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20066 PyObject *pyobj = 0;
20067
20068 {
20069 #if wxUSE_UNICODE
20070 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20071 #else
20072 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20073 #endif
20074 }
20075 return pyobj;
20076 }
20077
20078
20079 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20080 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20081 return 1;
20082 }
20083
20084
20085 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20086 PyObject *pyobj = 0;
20087
20088 {
20089 #if wxUSE_UNICODE
20090 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20091 #else
20092 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20093 #endif
20094 }
20095 return pyobj;
20096 }
20097
20098
20099 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20100 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20101 return 1;
20102 }
20103
20104
20105 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20106 PyObject *pyobj = 0;
20107
20108 {
20109 #if wxUSE_UNICODE
20110 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20111 #else
20112 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20113 #endif
20114 }
20115 return pyobj;
20116 }
20117
20118
20119 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20120 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20121 return 1;
20122 }
20123
20124
20125 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20126 PyObject *pyobj = 0;
20127
20128 {
20129 #if wxUSE_UNICODE
20130 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20131 #else
20132 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20133 #endif
20134 }
20135 return pyobj;
20136 }
20137
20138
20139 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20140 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20141 return 1;
20142 }
20143
20144
20145 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20146 PyObject *pyobj = 0;
20147
20148 {
20149 #if wxUSE_UNICODE
20150 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20151 #else
20152 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20153 #endif
20154 }
20155 return pyobj;
20156 }
20157
20158
20159 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20160 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20161 return 1;
20162 }
20163
20164
20165 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20166 PyObject *pyobj = 0;
20167
20168 {
20169 #if wxUSE_UNICODE
20170 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20171 #else
20172 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20173 #endif
20174 }
20175 return pyobj;
20176 }
20177
20178
20179 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20180 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20181 return 1;
20182 }
20183
20184
20185 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20186 PyObject *pyobj = 0;
20187
20188 {
20189 #if wxUSE_UNICODE
20190 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20191 #else
20192 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20193 #endif
20194 }
20195 return pyobj;
20196 }
20197
20198
20199 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20200 PyObject *resultobj = 0;
20201 wxBMPHandler *result = 0 ;
20202
20203 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20204 {
20205 PyThreadState* __tstate = wxPyBeginAllowThreads();
20206 result = (wxBMPHandler *)new wxBMPHandler();
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20218 PyObject *obj;
20219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20220 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20221 return SWIG_Py_Void();
20222 }
20223
20224 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20225 return SWIG_Python_InitShadowInstance(args);
20226 }
20227
20228 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20229 PyObject *resultobj = 0;
20230 wxICOHandler *result = 0 ;
20231
20232 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (wxICOHandler *)new wxICOHandler();
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20247 PyObject *obj;
20248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20249 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20250 return SWIG_Py_Void();
20251 }
20252
20253 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20254 return SWIG_Python_InitShadowInstance(args);
20255 }
20256
20257 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20258 PyObject *resultobj = 0;
20259 wxCURHandler *result = 0 ;
20260
20261 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 result = (wxCURHandler *)new wxCURHandler();
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20276 PyObject *obj;
20277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20278 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20279 return SWIG_Py_Void();
20280 }
20281
20282 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20283 return SWIG_Python_InitShadowInstance(args);
20284 }
20285
20286 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20287 PyObject *resultobj = 0;
20288 wxANIHandler *result = 0 ;
20289
20290 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (wxANIHandler *)new wxANIHandler();
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20298 return resultobj;
20299 fail:
20300 return NULL;
20301 }
20302
20303
20304 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20305 PyObject *obj;
20306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20307 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20308 return SWIG_Py_Void();
20309 }
20310
20311 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20312 return SWIG_Python_InitShadowInstance(args);
20313 }
20314
20315 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20316 PyObject *resultobj = 0;
20317 wxPNGHandler *result = 0 ;
20318
20319 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20320 {
20321 PyThreadState* __tstate = wxPyBeginAllowThreads();
20322 result = (wxPNGHandler *)new wxPNGHandler();
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20334 PyObject *obj;
20335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20336 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20337 return SWIG_Py_Void();
20338 }
20339
20340 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20341 return SWIG_Python_InitShadowInstance(args);
20342 }
20343
20344 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *resultobj = 0;
20346 wxGIFHandler *result = 0 ;
20347
20348 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = (wxGIFHandler *)new wxGIFHandler();
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20363 PyObject *obj;
20364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20365 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20366 return SWIG_Py_Void();
20367 }
20368
20369 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20370 return SWIG_Python_InitShadowInstance(args);
20371 }
20372
20373 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20374 PyObject *resultobj = 0;
20375 wxPCXHandler *result = 0 ;
20376
20377 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 result = (wxPCXHandler *)new wxPCXHandler();
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20392 PyObject *obj;
20393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20394 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20395 return SWIG_Py_Void();
20396 }
20397
20398 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20399 return SWIG_Python_InitShadowInstance(args);
20400 }
20401
20402 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20403 PyObject *resultobj = 0;
20404 wxJPEGHandler *result = 0 ;
20405
20406 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = (wxJPEGHandler *)new wxJPEGHandler();
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20414 return resultobj;
20415 fail:
20416 return NULL;
20417 }
20418
20419
20420 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20421 PyObject *obj;
20422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20423 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20424 return SWIG_Py_Void();
20425 }
20426
20427 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20428 return SWIG_Python_InitShadowInstance(args);
20429 }
20430
20431 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *resultobj = 0;
20433 wxPNMHandler *result = 0 ;
20434
20435 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (wxPNMHandler *)new wxPNMHandler();
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20450 PyObject *obj;
20451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20452 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20453 return SWIG_Py_Void();
20454 }
20455
20456 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 return SWIG_Python_InitShadowInstance(args);
20458 }
20459
20460 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20461 PyObject *resultobj = 0;
20462 wxXPMHandler *result = 0 ;
20463
20464 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20465 {
20466 PyThreadState* __tstate = wxPyBeginAllowThreads();
20467 result = (wxXPMHandler *)new wxXPMHandler();
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20472 return resultobj;
20473 fail:
20474 return NULL;
20475 }
20476
20477
20478 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20479 PyObject *obj;
20480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20481 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20482 return SWIG_Py_Void();
20483 }
20484
20485 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20486 return SWIG_Python_InitShadowInstance(args);
20487 }
20488
20489 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20490 PyObject *resultobj = 0;
20491 wxTIFFHandler *result = 0 ;
20492
20493 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20494 {
20495 PyThreadState* __tstate = wxPyBeginAllowThreads();
20496 result = (wxTIFFHandler *)new wxTIFFHandler();
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20501 return resultobj;
20502 fail:
20503 return NULL;
20504 }
20505
20506
20507 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20508 PyObject *obj;
20509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20510 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20511 return SWIG_Py_Void();
20512 }
20513
20514 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20515 return SWIG_Python_InitShadowInstance(args);
20516 }
20517
20518 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20519 PyObject *resultobj = 0;
20520 wxTGAHandler *result = 0 ;
20521
20522 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 result = (wxTGAHandler *)new wxTGAHandler();
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20537 PyObject *obj;
20538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20539 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20540 return SWIG_Py_Void();
20541 }
20542
20543 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 return SWIG_Python_InitShadowInstance(args);
20545 }
20546
20547 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj = 0;
20549 wxImage *arg1 = 0 ;
20550 wxImage *arg2 = 0 ;
20551 int arg3 = (int) 236 ;
20552 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20553 bool result;
20554 void *argp1 = 0 ;
20555 int res1 = 0 ;
20556 void *argp2 = 0 ;
20557 int res2 = 0 ;
20558 int val3 ;
20559 int ecode3 = 0 ;
20560 int val4 ;
20561 int ecode4 = 0 ;
20562 PyObject * obj0 = 0 ;
20563 PyObject * obj1 = 0 ;
20564 PyObject * obj2 = 0 ;
20565 PyObject * obj3 = 0 ;
20566 char * kwnames[] = {
20567 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20568 };
20569
20570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20571 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20572 if (!SWIG_IsOK(res1)) {
20573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20574 }
20575 if (!argp1) {
20576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20577 }
20578 arg1 = reinterpret_cast< wxImage * >(argp1);
20579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20580 if (!SWIG_IsOK(res2)) {
20581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20582 }
20583 if (!argp2) {
20584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20585 }
20586 arg2 = reinterpret_cast< wxImage * >(argp2);
20587 if (obj2) {
20588 ecode3 = SWIG_AsVal_int(obj2, &val3);
20589 if (!SWIG_IsOK(ecode3)) {
20590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20591 }
20592 arg3 = static_cast< int >(val3);
20593 }
20594 if (obj3) {
20595 ecode4 = SWIG_AsVal_int(obj3, &val4);
20596 if (!SWIG_IsOK(ecode4)) {
20597 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20598 }
20599 arg4 = static_cast< int >(val4);
20600 }
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 {
20608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20609 }
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20617 PyObject *obj;
20618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20619 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20620 return SWIG_Py_Void();
20621 }
20622
20623 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20624 PyObject *resultobj = 0;
20625 wxEvtHandler *result = 0 ;
20626
20627 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 result = (wxEvtHandler *)new wxEvtHandler();
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20642 PyObject *resultobj = 0;
20643 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20644 wxEvtHandler *result = 0 ;
20645 void *argp1 = 0 ;
20646 int res1 = 0 ;
20647 PyObject *swig_obj[1] ;
20648
20649 if (!args) SWIG_fail;
20650 swig_obj[0] = args;
20651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20652 if (!SWIG_IsOK(res1)) {
20653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20654 }
20655 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 {
20663 resultobj = wxPyMake_wxObject(result, 0);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20672 PyObject *resultobj = 0;
20673 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20674 wxEvtHandler *result = 0 ;
20675 void *argp1 = 0 ;
20676 int res1 = 0 ;
20677 PyObject *swig_obj[1] ;
20678
20679 if (!args) SWIG_fail;
20680 swig_obj[0] = args;
20681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20682 if (!SWIG_IsOK(res1)) {
20683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20684 }
20685 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = wxPyMake_wxObject(result, 0);
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj = 0;
20703 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20704 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20705 void *argp1 = 0 ;
20706 int res1 = 0 ;
20707 void *argp2 = 0 ;
20708 int res2 = 0 ;
20709 PyObject * obj0 = 0 ;
20710 PyObject * obj1 = 0 ;
20711 char * kwnames[] = {
20712 (char *) "self",(char *) "handler", NULL
20713 };
20714
20715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20717 if (!SWIG_IsOK(res1)) {
20718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20719 }
20720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20722 if (!SWIG_IsOK(res2)) {
20723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20724 }
20725 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 (arg1)->SetNextHandler(arg2);
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 resultobj = SWIG_Py_Void();
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20740 PyObject *resultobj = 0;
20741 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20742 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20743 void *argp1 = 0 ;
20744 int res1 = 0 ;
20745 void *argp2 = 0 ;
20746 int res2 = 0 ;
20747 PyObject * obj0 = 0 ;
20748 PyObject * obj1 = 0 ;
20749 char * kwnames[] = {
20750 (char *) "self",(char *) "handler", NULL
20751 };
20752
20753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20755 if (!SWIG_IsOK(res1)) {
20756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20757 }
20758 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20760 if (!SWIG_IsOK(res2)) {
20761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20762 }
20763 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20764 {
20765 PyThreadState* __tstate = wxPyBeginAllowThreads();
20766 (arg1)->SetPreviousHandler(arg2);
20767 wxPyEndAllowThreads(__tstate);
20768 if (PyErr_Occurred()) SWIG_fail;
20769 }
20770 resultobj = SWIG_Py_Void();
20771 return resultobj;
20772 fail:
20773 return NULL;
20774 }
20775
20776
20777 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20778 PyObject *resultobj = 0;
20779 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20780 bool result;
20781 void *argp1 = 0 ;
20782 int res1 = 0 ;
20783 PyObject *swig_obj[1] ;
20784
20785 if (!args) SWIG_fail;
20786 swig_obj[0] = args;
20787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20788 if (!SWIG_IsOK(res1)) {
20789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20790 }
20791 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20792 {
20793 PyThreadState* __tstate = wxPyBeginAllowThreads();
20794 result = (bool)(arg1)->GetEvtHandlerEnabled();
20795 wxPyEndAllowThreads(__tstate);
20796 if (PyErr_Occurred()) SWIG_fail;
20797 }
20798 {
20799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20800 }
20801 return resultobj;
20802 fail:
20803 return NULL;
20804 }
20805
20806
20807 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20808 PyObject *resultobj = 0;
20809 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20810 bool arg2 ;
20811 void *argp1 = 0 ;
20812 int res1 = 0 ;
20813 bool val2 ;
20814 int ecode2 = 0 ;
20815 PyObject * obj0 = 0 ;
20816 PyObject * obj1 = 0 ;
20817 char * kwnames[] = {
20818 (char *) "self",(char *) "enabled", NULL
20819 };
20820
20821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20823 if (!SWIG_IsOK(res1)) {
20824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20825 }
20826 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20828 if (!SWIG_IsOK(ecode2)) {
20829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20830 }
20831 arg2 = static_cast< bool >(val2);
20832 {
20833 PyThreadState* __tstate = wxPyBeginAllowThreads();
20834 (arg1)->SetEvtHandlerEnabled(arg2);
20835 wxPyEndAllowThreads(__tstate);
20836 if (PyErr_Occurred()) SWIG_fail;
20837 }
20838 resultobj = SWIG_Py_Void();
20839 return resultobj;
20840 fail:
20841 return NULL;
20842 }
20843
20844
20845 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20846 PyObject *resultobj = 0;
20847 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20848 wxEvent *arg2 = 0 ;
20849 bool result;
20850 void *argp1 = 0 ;
20851 int res1 = 0 ;
20852 void *argp2 = 0 ;
20853 int res2 = 0 ;
20854 PyObject * obj0 = 0 ;
20855 PyObject * obj1 = 0 ;
20856 char * kwnames[] = {
20857 (char *) "self",(char *) "event", NULL
20858 };
20859
20860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20862 if (!SWIG_IsOK(res1)) {
20863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20864 }
20865 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20867 if (!SWIG_IsOK(res2)) {
20868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20869 }
20870 if (!argp2) {
20871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20872 }
20873 arg2 = reinterpret_cast< wxEvent * >(argp2);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)(arg1)->ProcessEvent(*arg2);
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 {
20881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20882 }
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20890 PyObject *resultobj = 0;
20891 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20892 wxEvent *arg2 = 0 ;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 void *argp2 = 0 ;
20896 int res2 = 0 ;
20897 PyObject * obj0 = 0 ;
20898 PyObject * obj1 = 0 ;
20899 char * kwnames[] = {
20900 (char *) "self",(char *) "event", NULL
20901 };
20902
20903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20907 }
20908 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20910 if (!SWIG_IsOK(res2)) {
20911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20912 }
20913 if (!argp2) {
20914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20915 }
20916 arg2 = reinterpret_cast< wxEvent * >(argp2);
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 (arg1)->AddPendingEvent(*arg2);
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 resultobj = SWIG_Py_Void();
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931 PyObject *resultobj = 0;
20932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 PyObject *swig_obj[1] ;
20936
20937 if (!args) SWIG_fail;
20938 swig_obj[0] = args;
20939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20942 }
20943 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 (arg1)->ProcessPendingEvents();
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_Py_Void();
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj = 0;
20959 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20960 int arg2 ;
20961 int arg3 ;
20962 int arg4 ;
20963 PyObject *arg5 = (PyObject *) 0 ;
20964 void *argp1 = 0 ;
20965 int res1 = 0 ;
20966 int val2 ;
20967 int ecode2 = 0 ;
20968 int val3 ;
20969 int ecode3 = 0 ;
20970 int val4 ;
20971 int ecode4 = 0 ;
20972 PyObject * obj0 = 0 ;
20973 PyObject * obj1 = 0 ;
20974 PyObject * obj2 = 0 ;
20975 PyObject * obj3 = 0 ;
20976 PyObject * obj4 = 0 ;
20977 char * kwnames[] = {
20978 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20979 };
20980
20981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20985 }
20986 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20987 ecode2 = SWIG_AsVal_int(obj1, &val2);
20988 if (!SWIG_IsOK(ecode2)) {
20989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20990 }
20991 arg2 = static_cast< int >(val2);
20992 ecode3 = SWIG_AsVal_int(obj2, &val3);
20993 if (!SWIG_IsOK(ecode3)) {
20994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20995 }
20996 arg3 = static_cast< int >(val3);
20997 ecode4 = SWIG_AsVal_int(obj3, &val4);
20998 if (!SWIG_IsOK(ecode4)) {
20999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21000 }
21001 arg4 = static_cast< int >(val4);
21002 arg5 = obj4;
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 resultobj = SWIG_Py_Void();
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj = 0;
21018 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21019 int arg2 ;
21020 int arg3 = (int) -1 ;
21021 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21022 bool result;
21023 void *argp1 = 0 ;
21024 int res1 = 0 ;
21025 int val2 ;
21026 int ecode2 = 0 ;
21027 int val3 ;
21028 int ecode3 = 0 ;
21029 int val4 ;
21030 int ecode4 = 0 ;
21031 PyObject * obj0 = 0 ;
21032 PyObject * obj1 = 0 ;
21033 PyObject * obj2 = 0 ;
21034 PyObject * obj3 = 0 ;
21035 char * kwnames[] = {
21036 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21037 };
21038
21039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21041 if (!SWIG_IsOK(res1)) {
21042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21043 }
21044 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21045 ecode2 = SWIG_AsVal_int(obj1, &val2);
21046 if (!SWIG_IsOK(ecode2)) {
21047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21048 }
21049 arg2 = static_cast< int >(val2);
21050 if (obj2) {
21051 ecode3 = SWIG_AsVal_int(obj2, &val3);
21052 if (!SWIG_IsOK(ecode3)) {
21053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21054 }
21055 arg3 = static_cast< int >(val3);
21056 }
21057 if (obj3) {
21058 ecode4 = SWIG_AsVal_int(obj3, &val4);
21059 if (!SWIG_IsOK(ecode4)) {
21060 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21061 }
21062 arg4 = static_cast< wxEventType >(val4);
21063 }
21064 {
21065 PyThreadState* __tstate = wxPyBeginAllowThreads();
21066 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21067 wxPyEndAllowThreads(__tstate);
21068 if (PyErr_Occurred()) SWIG_fail;
21069 }
21070 {
21071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21072 }
21073 return resultobj;
21074 fail:
21075 return NULL;
21076 }
21077
21078
21079 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21080 PyObject *resultobj = 0;
21081 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21082 PyObject *arg2 = (PyObject *) 0 ;
21083 bool arg3 = (bool) true ;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 bool val3 ;
21087 int ecode3 = 0 ;
21088 PyObject * obj0 = 0 ;
21089 PyObject * obj1 = 0 ;
21090 PyObject * obj2 = 0 ;
21091 char * kwnames[] = {
21092 (char *) "self",(char *) "_self",(char *) "incref", NULL
21093 };
21094
21095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21099 }
21100 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21101 arg2 = obj1;
21102 if (obj2) {
21103 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21104 if (!SWIG_IsOK(ecode3)) {
21105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21106 }
21107 arg3 = static_cast< bool >(val3);
21108 }
21109 {
21110 PyThreadState* __tstate = wxPyBeginAllowThreads();
21111 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21112 wxPyEndAllowThreads(__tstate);
21113 if (PyErr_Occurred()) SWIG_fail;
21114 }
21115 resultobj = SWIG_Py_Void();
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *obj;
21124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21125 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21126 return SWIG_Py_Void();
21127 }
21128
21129 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 return SWIG_Python_InitShadowInstance(args);
21131 }
21132
21133 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21134 PyObject *resultobj = 0;
21135 wxEventType result;
21136
21137 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 result = (wxEventType)wxNewEventType();
21141 wxPyEndAllowThreads(__tstate);
21142 if (PyErr_Occurred()) SWIG_fail;
21143 }
21144 resultobj = SWIG_From_int(static_cast< int >(result));
21145 return resultobj;
21146 fail:
21147 return NULL;
21148 }
21149
21150
21151 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21152 PyObject *resultobj = 0;
21153 wxEvent *arg1 = (wxEvent *) 0 ;
21154 void *argp1 = 0 ;
21155 int res1 = 0 ;
21156 PyObject *swig_obj[1] ;
21157
21158 if (!args) SWIG_fail;
21159 swig_obj[0] = args;
21160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21161 if (!SWIG_IsOK(res1)) {
21162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21163 }
21164 arg1 = reinterpret_cast< wxEvent * >(argp1);
21165 {
21166 PyThreadState* __tstate = wxPyBeginAllowThreads();
21167 delete arg1;
21168
21169 wxPyEndAllowThreads(__tstate);
21170 if (PyErr_Occurred()) SWIG_fail;
21171 }
21172 resultobj = SWIG_Py_Void();
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21180 PyObject *resultobj = 0;
21181 wxEvent *arg1 = (wxEvent *) 0 ;
21182 wxEventType arg2 ;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 int val2 ;
21186 int ecode2 = 0 ;
21187 PyObject * obj0 = 0 ;
21188 PyObject * obj1 = 0 ;
21189 char * kwnames[] = {
21190 (char *) "self",(char *) "typ", NULL
21191 };
21192
21193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21195 if (!SWIG_IsOK(res1)) {
21196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21197 }
21198 arg1 = reinterpret_cast< wxEvent * >(argp1);
21199 ecode2 = SWIG_AsVal_int(obj1, &val2);
21200 if (!SWIG_IsOK(ecode2)) {
21201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21202 }
21203 arg2 = static_cast< wxEventType >(val2);
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 (arg1)->SetEventType(arg2);
21207 wxPyEndAllowThreads(__tstate);
21208 if (PyErr_Occurred()) SWIG_fail;
21209 }
21210 resultobj = SWIG_Py_Void();
21211 return resultobj;
21212 fail:
21213 return NULL;
21214 }
21215
21216
21217 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21218 PyObject *resultobj = 0;
21219 wxEvent *arg1 = (wxEvent *) 0 ;
21220 wxEventType result;
21221 void *argp1 = 0 ;
21222 int res1 = 0 ;
21223 PyObject *swig_obj[1] ;
21224
21225 if (!args) SWIG_fail;
21226 swig_obj[0] = args;
21227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21228 if (!SWIG_IsOK(res1)) {
21229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21230 }
21231 arg1 = reinterpret_cast< wxEvent * >(argp1);
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 resultobj = SWIG_From_int(static_cast< int >(result));
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21246 PyObject *resultobj = 0;
21247 wxEvent *arg1 = (wxEvent *) 0 ;
21248 wxObject *result = 0 ;
21249 void *argp1 = 0 ;
21250 int res1 = 0 ;
21251 PyObject *swig_obj[1] ;
21252
21253 if (!args) SWIG_fail;
21254 swig_obj[0] = args;
21255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21256 if (!SWIG_IsOK(res1)) {
21257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21258 }
21259 arg1 = reinterpret_cast< wxEvent * >(argp1);
21260 {
21261 PyThreadState* __tstate = wxPyBeginAllowThreads();
21262 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21263 wxPyEndAllowThreads(__tstate);
21264 if (PyErr_Occurred()) SWIG_fail;
21265 }
21266 {
21267 resultobj = wxPyMake_wxObject(result, (bool)0);
21268 }
21269 return resultobj;
21270 fail:
21271 return NULL;
21272 }
21273
21274
21275 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21276 PyObject *resultobj = 0;
21277 wxEvent *arg1 = (wxEvent *) 0 ;
21278 wxObject *arg2 = (wxObject *) 0 ;
21279 void *argp1 = 0 ;
21280 int res1 = 0 ;
21281 void *argp2 = 0 ;
21282 int res2 = 0 ;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char * kwnames[] = {
21286 (char *) "self",(char *) "obj", NULL
21287 };
21288
21289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21293 }
21294 arg1 = reinterpret_cast< wxEvent * >(argp1);
21295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21296 if (!SWIG_IsOK(res2)) {
21297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21298 }
21299 arg2 = reinterpret_cast< wxObject * >(argp2);
21300 {
21301 PyThreadState* __tstate = wxPyBeginAllowThreads();
21302 (arg1)->SetEventObject(arg2);
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_Py_Void();
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21314 PyObject *resultobj = 0;
21315 wxEvent *arg1 = (wxEvent *) 0 ;
21316 long result;
21317 void *argp1 = 0 ;
21318 int res1 = 0 ;
21319 PyObject *swig_obj[1] ;
21320
21321 if (!args) SWIG_fail;
21322 swig_obj[0] = args;
21323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21324 if (!SWIG_IsOK(res1)) {
21325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21326 }
21327 arg1 = reinterpret_cast< wxEvent * >(argp1);
21328 {
21329 PyThreadState* __tstate = wxPyBeginAllowThreads();
21330 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21331 wxPyEndAllowThreads(__tstate);
21332 if (PyErr_Occurred()) SWIG_fail;
21333 }
21334 resultobj = SWIG_From_long(static_cast< long >(result));
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj = 0;
21343 wxEvent *arg1 = (wxEvent *) 0 ;
21344 long arg2 = (long) 0 ;
21345 void *argp1 = 0 ;
21346 int res1 = 0 ;
21347 long val2 ;
21348 int ecode2 = 0 ;
21349 PyObject * obj0 = 0 ;
21350 PyObject * obj1 = 0 ;
21351 char * kwnames[] = {
21352 (char *) "self",(char *) "ts", NULL
21353 };
21354
21355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21357 if (!SWIG_IsOK(res1)) {
21358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21359 }
21360 arg1 = reinterpret_cast< wxEvent * >(argp1);
21361 if (obj1) {
21362 ecode2 = SWIG_AsVal_long(obj1, &val2);
21363 if (!SWIG_IsOK(ecode2)) {
21364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21365 }
21366 arg2 = static_cast< long >(val2);
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 (arg1)->SetTimestamp(arg2);
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 resultobj = SWIG_Py_Void();
21375 return resultobj;
21376 fail:
21377 return NULL;
21378 }
21379
21380
21381 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21382 PyObject *resultobj = 0;
21383 wxEvent *arg1 = (wxEvent *) 0 ;
21384 int result;
21385 void *argp1 = 0 ;
21386 int res1 = 0 ;
21387 PyObject *swig_obj[1] ;
21388
21389 if (!args) SWIG_fail;
21390 swig_obj[0] = args;
21391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21392 if (!SWIG_IsOK(res1)) {
21393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21394 }
21395 arg1 = reinterpret_cast< wxEvent * >(argp1);
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (int)((wxEvent const *)arg1)->GetId();
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 resultobj = SWIG_From_int(static_cast< int >(result));
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj = 0;
21411 wxEvent *arg1 = (wxEvent *) 0 ;
21412 int arg2 ;
21413 void *argp1 = 0 ;
21414 int res1 = 0 ;
21415 int val2 ;
21416 int ecode2 = 0 ;
21417 PyObject * obj0 = 0 ;
21418 PyObject * obj1 = 0 ;
21419 char * kwnames[] = {
21420 (char *) "self",(char *) "Id", NULL
21421 };
21422
21423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21425 if (!SWIG_IsOK(res1)) {
21426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21427 }
21428 arg1 = reinterpret_cast< wxEvent * >(argp1);
21429 ecode2 = SWIG_AsVal_int(obj1, &val2);
21430 if (!SWIG_IsOK(ecode2)) {
21431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21432 }
21433 arg2 = static_cast< int >(val2);
21434 {
21435 PyThreadState* __tstate = wxPyBeginAllowThreads();
21436 (arg1)->SetId(arg2);
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxEvent *arg1 = (wxEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21460 }
21461 arg1 = reinterpret_cast< wxEvent * >(argp1);
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 {
21469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21470 }
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21478 PyObject *resultobj = 0;
21479 wxEvent *arg1 = (wxEvent *) 0 ;
21480 bool arg2 = (bool) true ;
21481 void *argp1 = 0 ;
21482 int res1 = 0 ;
21483 bool val2 ;
21484 int ecode2 = 0 ;
21485 PyObject * obj0 = 0 ;
21486 PyObject * obj1 = 0 ;
21487 char * kwnames[] = {
21488 (char *) "self",(char *) "skip", NULL
21489 };
21490
21491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21495 }
21496 arg1 = reinterpret_cast< wxEvent * >(argp1);
21497 if (obj1) {
21498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21499 if (!SWIG_IsOK(ecode2)) {
21500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21501 }
21502 arg2 = static_cast< bool >(val2);
21503 }
21504 {
21505 PyThreadState* __tstate = wxPyBeginAllowThreads();
21506 (arg1)->Skip(arg2);
21507 wxPyEndAllowThreads(__tstate);
21508 if (PyErr_Occurred()) SWIG_fail;
21509 }
21510 resultobj = SWIG_Py_Void();
21511 return resultobj;
21512 fail:
21513 return NULL;
21514 }
21515
21516
21517 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21518 PyObject *resultobj = 0;
21519 wxEvent *arg1 = (wxEvent *) 0 ;
21520 bool result;
21521 void *argp1 = 0 ;
21522 int res1 = 0 ;
21523 PyObject *swig_obj[1] ;
21524
21525 if (!args) SWIG_fail;
21526 swig_obj[0] = args;
21527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21528 if (!SWIG_IsOK(res1)) {
21529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21530 }
21531 arg1 = reinterpret_cast< wxEvent * >(argp1);
21532 {
21533 PyThreadState* __tstate = wxPyBeginAllowThreads();
21534 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21535 wxPyEndAllowThreads(__tstate);
21536 if (PyErr_Occurred()) SWIG_fail;
21537 }
21538 {
21539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21540 }
21541 return resultobj;
21542 fail:
21543 return NULL;
21544 }
21545
21546
21547 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21548 PyObject *resultobj = 0;
21549 wxEvent *arg1 = (wxEvent *) 0 ;
21550 bool result;
21551 void *argp1 = 0 ;
21552 int res1 = 0 ;
21553 PyObject *swig_obj[1] ;
21554
21555 if (!args) SWIG_fail;
21556 swig_obj[0] = args;
21557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21558 if (!SWIG_IsOK(res1)) {
21559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21560 }
21561 arg1 = reinterpret_cast< wxEvent * >(argp1);
21562 {
21563 PyThreadState* __tstate = wxPyBeginAllowThreads();
21564 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 {
21569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21570 }
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21578 PyObject *resultobj = 0;
21579 wxEvent *arg1 = (wxEvent *) 0 ;
21580 int result;
21581 void *argp1 = 0 ;
21582 int res1 = 0 ;
21583 PyObject *swig_obj[1] ;
21584
21585 if (!args) SWIG_fail;
21586 swig_obj[0] = args;
21587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21588 if (!SWIG_IsOK(res1)) {
21589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21590 }
21591 arg1 = reinterpret_cast< wxEvent * >(argp1);
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (int)(arg1)->StopPropagation();
21595 wxPyEndAllowThreads(__tstate);
21596 if (PyErr_Occurred()) SWIG_fail;
21597 }
21598 resultobj = SWIG_From_int(static_cast< int >(result));
21599 return resultobj;
21600 fail:
21601 return NULL;
21602 }
21603
21604
21605 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21606 PyObject *resultobj = 0;
21607 wxEvent *arg1 = (wxEvent *) 0 ;
21608 int arg2 ;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 int val2 ;
21612 int ecode2 = 0 ;
21613 PyObject * obj0 = 0 ;
21614 PyObject * obj1 = 0 ;
21615 char * kwnames[] = {
21616 (char *) "self",(char *) "propagationLevel", NULL
21617 };
21618
21619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21621 if (!SWIG_IsOK(res1)) {
21622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21623 }
21624 arg1 = reinterpret_cast< wxEvent * >(argp1);
21625 ecode2 = SWIG_AsVal_int(obj1, &val2);
21626 if (!SWIG_IsOK(ecode2)) {
21627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21628 }
21629 arg2 = static_cast< int >(val2);
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 (arg1)->ResumePropagation(arg2);
21633 wxPyEndAllowThreads(__tstate);
21634 if (PyErr_Occurred()) SWIG_fail;
21635 }
21636 resultobj = SWIG_Py_Void();
21637 return resultobj;
21638 fail:
21639 return NULL;
21640 }
21641
21642
21643 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21644 PyObject *resultobj = 0;
21645 wxEvent *arg1 = (wxEvent *) 0 ;
21646 wxEvent *result = 0 ;
21647 void *argp1 = 0 ;
21648 int res1 = 0 ;
21649 PyObject *swig_obj[1] ;
21650
21651 if (!args) SWIG_fail;
21652 swig_obj[0] = args;
21653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21654 if (!SWIG_IsOK(res1)) {
21655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21656 }
21657 arg1 = reinterpret_cast< wxEvent * >(argp1);
21658 {
21659 PyThreadState* __tstate = wxPyBeginAllowThreads();
21660 result = (wxEvent *)(arg1)->Clone();
21661 wxPyEndAllowThreads(__tstate);
21662 if (PyErr_Occurred()) SWIG_fail;
21663 }
21664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21665 return resultobj;
21666 fail:
21667 return NULL;
21668 }
21669
21670
21671 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21672 PyObject *obj;
21673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21674 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21675 return SWIG_Py_Void();
21676 }
21677
21678 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj = 0;
21680 wxEvent *arg1 = 0 ;
21681 wxPropagationDisabler *result = 0 ;
21682 void *argp1 = 0 ;
21683 int res1 = 0 ;
21684 PyObject * obj0 = 0 ;
21685 char * kwnames[] = {
21686 (char *) "event", NULL
21687 };
21688
21689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21690 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21691 if (!SWIG_IsOK(res1)) {
21692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21693 }
21694 if (!argp1) {
21695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21696 }
21697 arg1 = reinterpret_cast< wxEvent * >(argp1);
21698 {
21699 PyThreadState* __tstate = wxPyBeginAllowThreads();
21700 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21712 PyObject *resultobj = 0;
21713 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21714 void *argp1 = 0 ;
21715 int res1 = 0 ;
21716 PyObject *swig_obj[1] ;
21717
21718 if (!args) SWIG_fail;
21719 swig_obj[0] = args;
21720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21723 }
21724 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21725 {
21726 PyThreadState* __tstate = wxPyBeginAllowThreads();
21727 delete arg1;
21728
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 resultobj = SWIG_Py_Void();
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21740 PyObject *obj;
21741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21742 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21743 return SWIG_Py_Void();
21744 }
21745
21746 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21747 return SWIG_Python_InitShadowInstance(args);
21748 }
21749
21750 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21751 PyObject *resultobj = 0;
21752 wxEvent *arg1 = 0 ;
21753 wxPropagateOnce *result = 0 ;
21754 void *argp1 = 0 ;
21755 int res1 = 0 ;
21756 PyObject * obj0 = 0 ;
21757 char * kwnames[] = {
21758 (char *) "event", NULL
21759 };
21760
21761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21762 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21763 if (!SWIG_IsOK(res1)) {
21764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21765 }
21766 if (!argp1) {
21767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21768 }
21769 arg1 = reinterpret_cast< wxEvent * >(argp1);
21770 {
21771 PyThreadState* __tstate = wxPyBeginAllowThreads();
21772 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21773 wxPyEndAllowThreads(__tstate);
21774 if (PyErr_Occurred()) SWIG_fail;
21775 }
21776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21777 return resultobj;
21778 fail:
21779 return NULL;
21780 }
21781
21782
21783 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21784 PyObject *resultobj = 0;
21785 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21786 void *argp1 = 0 ;
21787 int res1 = 0 ;
21788 PyObject *swig_obj[1] ;
21789
21790 if (!args) SWIG_fail;
21791 swig_obj[0] = args;
21792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21793 if (!SWIG_IsOK(res1)) {
21794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21795 }
21796 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21797 {
21798 PyThreadState* __tstate = wxPyBeginAllowThreads();
21799 delete arg1;
21800
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 resultobj = SWIG_Py_Void();
21805 return resultobj;
21806 fail:
21807 return NULL;
21808 }
21809
21810
21811 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21812 PyObject *obj;
21813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21814 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21815 return SWIG_Py_Void();
21816 }
21817
21818 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21819 return SWIG_Python_InitShadowInstance(args);
21820 }
21821
21822 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = 0;
21824 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21825 int arg2 = (int) 0 ;
21826 wxCommandEvent *result = 0 ;
21827 int val1 ;
21828 int ecode1 = 0 ;
21829 int val2 ;
21830 int ecode2 = 0 ;
21831 PyObject * obj0 = 0 ;
21832 PyObject * obj1 = 0 ;
21833 char * kwnames[] = {
21834 (char *) "commandType",(char *) "winid", NULL
21835 };
21836
21837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21838 if (obj0) {
21839 ecode1 = SWIG_AsVal_int(obj0, &val1);
21840 if (!SWIG_IsOK(ecode1)) {
21841 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21842 }
21843 arg1 = static_cast< wxEventType >(val1);
21844 }
21845 if (obj1) {
21846 ecode2 = SWIG_AsVal_int(obj1, &val2);
21847 if (!SWIG_IsOK(ecode2)) {
21848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21849 }
21850 arg2 = static_cast< int >(val2);
21851 }
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21855 wxPyEndAllowThreads(__tstate);
21856 if (PyErr_Occurred()) SWIG_fail;
21857 }
21858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21866 PyObject *resultobj = 0;
21867 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21868 int result;
21869 void *argp1 = 0 ;
21870 int res1 = 0 ;
21871 PyObject *swig_obj[1] ;
21872
21873 if (!args) SWIG_fail;
21874 swig_obj[0] = args;
21875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21876 if (!SWIG_IsOK(res1)) {
21877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21878 }
21879 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 resultobj = SWIG_From_int(static_cast< int >(result));
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21894 PyObject *resultobj = 0;
21895 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21896 wxString *arg2 = 0 ;
21897 void *argp1 = 0 ;
21898 int res1 = 0 ;
21899 bool temp2 = false ;
21900 PyObject * obj0 = 0 ;
21901 PyObject * obj1 = 0 ;
21902 char * kwnames[] = {
21903 (char *) "self",(char *) "s", NULL
21904 };
21905
21906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21908 if (!SWIG_IsOK(res1)) {
21909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21910 }
21911 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21912 {
21913 arg2 = wxString_in_helper(obj1);
21914 if (arg2 == NULL) SWIG_fail;
21915 temp2 = true;
21916 }
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 (arg1)->SetString((wxString const &)*arg2);
21920 wxPyEndAllowThreads(__tstate);
21921 if (PyErr_Occurred()) SWIG_fail;
21922 }
21923 resultobj = SWIG_Py_Void();
21924 {
21925 if (temp2)
21926 delete arg2;
21927 }
21928 return resultobj;
21929 fail:
21930 {
21931 if (temp2)
21932 delete arg2;
21933 }
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21939 PyObject *resultobj = 0;
21940 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21941 wxString result;
21942 void *argp1 = 0 ;
21943 int res1 = 0 ;
21944 PyObject *swig_obj[1] ;
21945
21946 if (!args) SWIG_fail;
21947 swig_obj[0] = args;
21948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21949 if (!SWIG_IsOK(res1)) {
21950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21951 }
21952 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 result = ((wxCommandEvent const *)arg1)->GetString();
21956 wxPyEndAllowThreads(__tstate);
21957 if (PyErr_Occurred()) SWIG_fail;
21958 }
21959 {
21960 #if wxUSE_UNICODE
21961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21962 #else
21963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21964 #endif
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21973 PyObject *resultobj = 0;
21974 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21975 bool result;
21976 void *argp1 = 0 ;
21977 int res1 = 0 ;
21978 PyObject *swig_obj[1] ;
21979
21980 if (!args) SWIG_fail;
21981 swig_obj[0] = args;
21982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21983 if (!SWIG_IsOK(res1)) {
21984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21985 }
21986 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22003 PyObject *resultobj = 0;
22004 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22005 bool result;
22006 void *argp1 = 0 ;
22007 int res1 = 0 ;
22008 PyObject *swig_obj[1] ;
22009
22010 if (!args) SWIG_fail;
22011 swig_obj[0] = args;
22012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22015 }
22016 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 {
22024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22025 }
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj = 0;
22034 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22035 long arg2 ;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 long val2 ;
22039 int ecode2 = 0 ;
22040 PyObject * obj0 = 0 ;
22041 PyObject * obj1 = 0 ;
22042 char * kwnames[] = {
22043 (char *) "self",(char *) "extraLong", NULL
22044 };
22045
22046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22048 if (!SWIG_IsOK(res1)) {
22049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22050 }
22051 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22052 ecode2 = SWIG_AsVal_long(obj1, &val2);
22053 if (!SWIG_IsOK(ecode2)) {
22054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22055 }
22056 arg2 = static_cast< long >(val2);
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 (arg1)->SetExtraLong(arg2);
22060 wxPyEndAllowThreads(__tstate);
22061 if (PyErr_Occurred()) SWIG_fail;
22062 }
22063 resultobj = SWIG_Py_Void();
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22071 PyObject *resultobj = 0;
22072 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22073 long result;
22074 void *argp1 = 0 ;
22075 int res1 = 0 ;
22076 PyObject *swig_obj[1] ;
22077
22078 if (!args) SWIG_fail;
22079 swig_obj[0] = args;
22080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22081 if (!SWIG_IsOK(res1)) {
22082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22083 }
22084 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 resultobj = SWIG_From_long(static_cast< long >(result));
22092 return resultobj;
22093 fail:
22094 return NULL;
22095 }
22096
22097
22098 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22099 PyObject *resultobj = 0;
22100 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22101 int arg2 ;
22102 void *argp1 = 0 ;
22103 int res1 = 0 ;
22104 int val2 ;
22105 int ecode2 = 0 ;
22106 PyObject * obj0 = 0 ;
22107 PyObject * obj1 = 0 ;
22108 char * kwnames[] = {
22109 (char *) "self",(char *) "i", NULL
22110 };
22111
22112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22114 if (!SWIG_IsOK(res1)) {
22115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22116 }
22117 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22118 ecode2 = SWIG_AsVal_int(obj1, &val2);
22119 if (!SWIG_IsOK(ecode2)) {
22120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22121 }
22122 arg2 = static_cast< int >(val2);
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 (arg1)->SetInt(arg2);
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_Py_Void();
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22137 PyObject *resultobj = 0;
22138 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22139 int result;
22140 void *argp1 = 0 ;
22141 int res1 = 0 ;
22142 PyObject *swig_obj[1] ;
22143
22144 if (!args) SWIG_fail;
22145 swig_obj[0] = args;
22146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22147 if (!SWIG_IsOK(res1)) {
22148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22149 }
22150 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 resultobj = SWIG_From_int(static_cast< int >(result));
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22165 PyObject *resultobj = 0;
22166 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22167 PyObject *result = 0 ;
22168 void *argp1 = 0 ;
22169 int res1 = 0 ;
22170 PyObject *swig_obj[1] ;
22171
22172 if (!args) SWIG_fail;
22173 swig_obj[0] = args;
22174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22175 if (!SWIG_IsOK(res1)) {
22176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22177 }
22178 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22182 wxPyEndAllowThreads(__tstate);
22183 if (PyErr_Occurred()) SWIG_fail;
22184 }
22185 resultobj = result;
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = 0;
22194 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22195 PyObject *arg2 = (PyObject *) 0 ;
22196 void *argp1 = 0 ;
22197 int res1 = 0 ;
22198 PyObject * obj0 = 0 ;
22199 PyObject * obj1 = 0 ;
22200 char * kwnames[] = {
22201 (char *) "self",(char *) "clientData", NULL
22202 };
22203
22204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22206 if (!SWIG_IsOK(res1)) {
22207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22208 }
22209 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22210 arg2 = obj1;
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 wxCommandEvent_SetClientData(arg1,arg2);
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 resultobj = SWIG_Py_Void();
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22225 PyObject *resultobj = 0;
22226 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22227 wxEvent *result = 0 ;
22228 void *argp1 = 0 ;
22229 int res1 = 0 ;
22230 PyObject *swig_obj[1] ;
22231
22232 if (!args) SWIG_fail;
22233 swig_obj[0] = args;
22234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22237 }
22238 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22253 PyObject *obj;
22254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22255 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22256 return SWIG_Py_Void();
22257 }
22258
22259 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22260 return SWIG_Python_InitShadowInstance(args);
22261 }
22262
22263 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj = 0;
22265 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22266 int arg2 = (int) 0 ;
22267 wxNotifyEvent *result = 0 ;
22268 int val1 ;
22269 int ecode1 = 0 ;
22270 int val2 ;
22271 int ecode2 = 0 ;
22272 PyObject * obj0 = 0 ;
22273 PyObject * obj1 = 0 ;
22274 char * kwnames[] = {
22275 (char *) "commandType",(char *) "winid", NULL
22276 };
22277
22278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22279 if (obj0) {
22280 ecode1 = SWIG_AsVal_int(obj0, &val1);
22281 if (!SWIG_IsOK(ecode1)) {
22282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22283 }
22284 arg1 = static_cast< wxEventType >(val1);
22285 }
22286 if (obj1) {
22287 ecode2 = SWIG_AsVal_int(obj1, &val2);
22288 if (!SWIG_IsOK(ecode2)) {
22289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22290 }
22291 arg2 = static_cast< int >(val2);
22292 }
22293 {
22294 PyThreadState* __tstate = wxPyBeginAllowThreads();
22295 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22296 wxPyEndAllowThreads(__tstate);
22297 if (PyErr_Occurred()) SWIG_fail;
22298 }
22299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22300 return resultobj;
22301 fail:
22302 return NULL;
22303 }
22304
22305
22306 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22307 PyObject *resultobj = 0;
22308 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22309 void *argp1 = 0 ;
22310 int res1 = 0 ;
22311 PyObject *swig_obj[1] ;
22312
22313 if (!args) SWIG_fail;
22314 swig_obj[0] = args;
22315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22316 if (!SWIG_IsOK(res1)) {
22317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22318 }
22319 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 (arg1)->Veto();
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 resultobj = SWIG_Py_Void();
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22334 PyObject *resultobj = 0;
22335 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22336 void *argp1 = 0 ;
22337 int res1 = 0 ;
22338 PyObject *swig_obj[1] ;
22339
22340 if (!args) SWIG_fail;
22341 swig_obj[0] = args;
22342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22343 if (!SWIG_IsOK(res1)) {
22344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22345 }
22346 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22347 {
22348 PyThreadState* __tstate = wxPyBeginAllowThreads();
22349 (arg1)->Allow();
22350 wxPyEndAllowThreads(__tstate);
22351 if (PyErr_Occurred()) SWIG_fail;
22352 }
22353 resultobj = SWIG_Py_Void();
22354 return resultobj;
22355 fail:
22356 return NULL;
22357 }
22358
22359
22360 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22361 PyObject *resultobj = 0;
22362 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22363 bool result;
22364 void *argp1 = 0 ;
22365 int res1 = 0 ;
22366 PyObject *swig_obj[1] ;
22367
22368 if (!args) SWIG_fail;
22369 swig_obj[0] = args;
22370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22371 if (!SWIG_IsOK(res1)) {
22372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22373 }
22374 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 result = (bool)(arg1)->IsAllowed();
22378 wxPyEndAllowThreads(__tstate);
22379 if (PyErr_Occurred()) SWIG_fail;
22380 }
22381 {
22382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22383 }
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 PyObject *obj;
22392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22393 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22394 return SWIG_Py_Void();
22395 }
22396
22397 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22398 return SWIG_Python_InitShadowInstance(args);
22399 }
22400
22401 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22402 PyObject *resultobj = 0;
22403 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22404 int arg2 = (int) 0 ;
22405 int arg3 = (int) 0 ;
22406 int arg4 = (int) 0 ;
22407 wxScrollEvent *result = 0 ;
22408 int val1 ;
22409 int ecode1 = 0 ;
22410 int val2 ;
22411 int ecode2 = 0 ;
22412 int val3 ;
22413 int ecode3 = 0 ;
22414 int val4 ;
22415 int ecode4 = 0 ;
22416 PyObject * obj0 = 0 ;
22417 PyObject * obj1 = 0 ;
22418 PyObject * obj2 = 0 ;
22419 PyObject * obj3 = 0 ;
22420 char * kwnames[] = {
22421 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22422 };
22423
22424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22425 if (obj0) {
22426 ecode1 = SWIG_AsVal_int(obj0, &val1);
22427 if (!SWIG_IsOK(ecode1)) {
22428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22429 }
22430 arg1 = static_cast< wxEventType >(val1);
22431 }
22432 if (obj1) {
22433 ecode2 = SWIG_AsVal_int(obj1, &val2);
22434 if (!SWIG_IsOK(ecode2)) {
22435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22436 }
22437 arg2 = static_cast< int >(val2);
22438 }
22439 if (obj2) {
22440 ecode3 = SWIG_AsVal_int(obj2, &val3);
22441 if (!SWIG_IsOK(ecode3)) {
22442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22443 }
22444 arg3 = static_cast< int >(val3);
22445 }
22446 if (obj3) {
22447 ecode4 = SWIG_AsVal_int(obj3, &val4);
22448 if (!SWIG_IsOK(ecode4)) {
22449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22450 }
22451 arg4 = static_cast< int >(val4);
22452 }
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22467 PyObject *resultobj = 0;
22468 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22469 int result;
22470 void *argp1 = 0 ;
22471 int res1 = 0 ;
22472 PyObject *swig_obj[1] ;
22473
22474 if (!args) SWIG_fail;
22475 swig_obj[0] = args;
22476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22477 if (!SWIG_IsOK(res1)) {
22478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22479 }
22480 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22481 {
22482 PyThreadState* __tstate = wxPyBeginAllowThreads();
22483 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22484 wxPyEndAllowThreads(__tstate);
22485 if (PyErr_Occurred()) SWIG_fail;
22486 }
22487 resultobj = SWIG_From_int(static_cast< int >(result));
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 PyObject *resultobj = 0;
22496 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22497 int result;
22498 void *argp1 = 0 ;
22499 int res1 = 0 ;
22500 PyObject *swig_obj[1] ;
22501
22502 if (!args) SWIG_fail;
22503 swig_obj[0] = args;
22504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22507 }
22508 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22509 {
22510 PyThreadState* __tstate = wxPyBeginAllowThreads();
22511 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 resultobj = SWIG_From_int(static_cast< int >(result));
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22523 PyObject *resultobj = 0;
22524 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22525 int arg2 ;
22526 void *argp1 = 0 ;
22527 int res1 = 0 ;
22528 int val2 ;
22529 int ecode2 = 0 ;
22530 PyObject * obj0 = 0 ;
22531 PyObject * obj1 = 0 ;
22532 char * kwnames[] = {
22533 (char *) "self",(char *) "orient", NULL
22534 };
22535
22536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22542 ecode2 = SWIG_AsVal_int(obj1, &val2);
22543 if (!SWIG_IsOK(ecode2)) {
22544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22545 }
22546 arg2 = static_cast< int >(val2);
22547 {
22548 PyThreadState* __tstate = wxPyBeginAllowThreads();
22549 (arg1)->SetOrientation(arg2);
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 resultobj = SWIG_Py_Void();
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj = 0;
22562 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22563 int arg2 ;
22564 void *argp1 = 0 ;
22565 int res1 = 0 ;
22566 int val2 ;
22567 int ecode2 = 0 ;
22568 PyObject * obj0 = 0 ;
22569 PyObject * obj1 = 0 ;
22570 char * kwnames[] = {
22571 (char *) "self",(char *) "pos", NULL
22572 };
22573
22574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22576 if (!SWIG_IsOK(res1)) {
22577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22578 }
22579 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22580 ecode2 = SWIG_AsVal_int(obj1, &val2);
22581 if (!SWIG_IsOK(ecode2)) {
22582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22583 }
22584 arg2 = static_cast< int >(val2);
22585 {
22586 PyThreadState* __tstate = wxPyBeginAllowThreads();
22587 (arg1)->SetPosition(arg2);
22588 wxPyEndAllowThreads(__tstate);
22589 if (PyErr_Occurred()) SWIG_fail;
22590 }
22591 resultobj = SWIG_Py_Void();
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22599 PyObject *obj;
22600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22601 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22602 return SWIG_Py_Void();
22603 }
22604
22605 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22606 return SWIG_Python_InitShadowInstance(args);
22607 }
22608
22609 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22610 PyObject *resultobj = 0;
22611 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22612 int arg2 = (int) 0 ;
22613 int arg3 = (int) 0 ;
22614 wxScrollWinEvent *result = 0 ;
22615 int val1 ;
22616 int ecode1 = 0 ;
22617 int val2 ;
22618 int ecode2 = 0 ;
22619 int val3 ;
22620 int ecode3 = 0 ;
22621 PyObject * obj0 = 0 ;
22622 PyObject * obj1 = 0 ;
22623 PyObject * obj2 = 0 ;
22624 char * kwnames[] = {
22625 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22626 };
22627
22628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22629 if (obj0) {
22630 ecode1 = SWIG_AsVal_int(obj0, &val1);
22631 if (!SWIG_IsOK(ecode1)) {
22632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22633 }
22634 arg1 = static_cast< wxEventType >(val1);
22635 }
22636 if (obj1) {
22637 ecode2 = SWIG_AsVal_int(obj1, &val2);
22638 if (!SWIG_IsOK(ecode2)) {
22639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22640 }
22641 arg2 = static_cast< int >(val2);
22642 }
22643 if (obj2) {
22644 ecode3 = SWIG_AsVal_int(obj2, &val3);
22645 if (!SWIG_IsOK(ecode3)) {
22646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22647 }
22648 arg3 = static_cast< int >(val3);
22649 }
22650 {
22651 PyThreadState* __tstate = wxPyBeginAllowThreads();
22652 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22653 wxPyEndAllowThreads(__tstate);
22654 if (PyErr_Occurred()) SWIG_fail;
22655 }
22656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22657 return resultobj;
22658 fail:
22659 return NULL;
22660 }
22661
22662
22663 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22664 PyObject *resultobj = 0;
22665 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22666 int result;
22667 void *argp1 = 0 ;
22668 int res1 = 0 ;
22669 PyObject *swig_obj[1] ;
22670
22671 if (!args) SWIG_fail;
22672 swig_obj[0] = args;
22673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22674 if (!SWIG_IsOK(res1)) {
22675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22676 }
22677 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22678 {
22679 PyThreadState* __tstate = wxPyBeginAllowThreads();
22680 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22681 wxPyEndAllowThreads(__tstate);
22682 if (PyErr_Occurred()) SWIG_fail;
22683 }
22684 resultobj = SWIG_From_int(static_cast< int >(result));
22685 return resultobj;
22686 fail:
22687 return NULL;
22688 }
22689
22690
22691 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22692 PyObject *resultobj = 0;
22693 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22694 int result;
22695 void *argp1 = 0 ;
22696 int res1 = 0 ;
22697 PyObject *swig_obj[1] ;
22698
22699 if (!args) SWIG_fail;
22700 swig_obj[0] = args;
22701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22702 if (!SWIG_IsOK(res1)) {
22703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22704 }
22705 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22706 {
22707 PyThreadState* __tstate = wxPyBeginAllowThreads();
22708 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22709 wxPyEndAllowThreads(__tstate);
22710 if (PyErr_Occurred()) SWIG_fail;
22711 }
22712 resultobj = SWIG_From_int(static_cast< int >(result));
22713 return resultobj;
22714 fail:
22715 return NULL;
22716 }
22717
22718
22719 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22720 PyObject *resultobj = 0;
22721 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22722 int arg2 ;
22723 void *argp1 = 0 ;
22724 int res1 = 0 ;
22725 int val2 ;
22726 int ecode2 = 0 ;
22727 PyObject * obj0 = 0 ;
22728 PyObject * obj1 = 0 ;
22729 char * kwnames[] = {
22730 (char *) "self",(char *) "orient", NULL
22731 };
22732
22733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22735 if (!SWIG_IsOK(res1)) {
22736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22737 }
22738 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22739 ecode2 = SWIG_AsVal_int(obj1, &val2);
22740 if (!SWIG_IsOK(ecode2)) {
22741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22742 }
22743 arg2 = static_cast< int >(val2);
22744 {
22745 PyThreadState* __tstate = wxPyBeginAllowThreads();
22746 (arg1)->SetOrientation(arg2);
22747 wxPyEndAllowThreads(__tstate);
22748 if (PyErr_Occurred()) SWIG_fail;
22749 }
22750 resultobj = SWIG_Py_Void();
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22758 PyObject *resultobj = 0;
22759 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22760 int arg2 ;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 int val2 ;
22764 int ecode2 = 0 ;
22765 PyObject * obj0 = 0 ;
22766 PyObject * obj1 = 0 ;
22767 char * kwnames[] = {
22768 (char *) "self",(char *) "pos", NULL
22769 };
22770
22771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22773 if (!SWIG_IsOK(res1)) {
22774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22775 }
22776 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22777 ecode2 = SWIG_AsVal_int(obj1, &val2);
22778 if (!SWIG_IsOK(ecode2)) {
22779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22780 }
22781 arg2 = static_cast< int >(val2);
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 (arg1)->SetPosition(arg2);
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_Py_Void();
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22796 PyObject *obj;
22797 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22798 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22799 return SWIG_Py_Void();
22800 }
22801
22802 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22803 return SWIG_Python_InitShadowInstance(args);
22804 }
22805
22806 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22807 PyObject *resultobj = 0;
22808 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22809 wxMouseEvent *result = 0 ;
22810 int val1 ;
22811 int ecode1 = 0 ;
22812 PyObject * obj0 = 0 ;
22813 char * kwnames[] = {
22814 (char *) "mouseType", NULL
22815 };
22816
22817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22818 if (obj0) {
22819 ecode1 = SWIG_AsVal_int(obj0, &val1);
22820 if (!SWIG_IsOK(ecode1)) {
22821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22822 }
22823 arg1 = static_cast< wxEventType >(val1);
22824 }
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22839 PyObject *resultobj = 0;
22840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22841 bool result;
22842 void *argp1 = 0 ;
22843 int res1 = 0 ;
22844 PyObject *swig_obj[1] ;
22845
22846 if (!args) SWIG_fail;
22847 swig_obj[0] = args;
22848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22849 if (!SWIG_IsOK(res1)) {
22850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22851 }
22852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 {
22860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22861 }
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22869 PyObject *resultobj = 0;
22870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22871 int arg2 = (int) wxMOUSE_BTN_ANY ;
22872 bool result;
22873 void *argp1 = 0 ;
22874 int res1 = 0 ;
22875 int val2 ;
22876 int ecode2 = 0 ;
22877 PyObject * obj0 = 0 ;
22878 PyObject * obj1 = 0 ;
22879 char * kwnames[] = {
22880 (char *) "self",(char *) "but", NULL
22881 };
22882
22883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22887 }
22888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22889 if (obj1) {
22890 ecode2 = SWIG_AsVal_int(obj1, &val2);
22891 if (!SWIG_IsOK(ecode2)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22893 }
22894 arg2 = static_cast< int >(val2);
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 {
22903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22904 }
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22912 PyObject *resultobj = 0;
22913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22914 int arg2 = (int) wxMOUSE_BTN_ANY ;
22915 bool result;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 int val2 ;
22919 int ecode2 = 0 ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 char * kwnames[] = {
22923 (char *) "self",(char *) "but", NULL
22924 };
22925
22926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22928 if (!SWIG_IsOK(res1)) {
22929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22930 }
22931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22932 if (obj1) {
22933 ecode2 = SWIG_AsVal_int(obj1, &val2);
22934 if (!SWIG_IsOK(ecode2)) {
22935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22936 }
22937 arg2 = static_cast< int >(val2);
22938 }
22939 {
22940 PyThreadState* __tstate = wxPyBeginAllowThreads();
22941 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22942 wxPyEndAllowThreads(__tstate);
22943 if (PyErr_Occurred()) SWIG_fail;
22944 }
22945 {
22946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22947 }
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22955 PyObject *resultobj = 0;
22956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22957 int arg2 = (int) wxMOUSE_BTN_ANY ;
22958 bool result;
22959 void *argp1 = 0 ;
22960 int res1 = 0 ;
22961 int val2 ;
22962 int ecode2 = 0 ;
22963 PyObject * obj0 = 0 ;
22964 PyObject * obj1 = 0 ;
22965 char * kwnames[] = {
22966 (char *) "self",(char *) "but", NULL
22967 };
22968
22969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22973 }
22974 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22975 if (obj1) {
22976 ecode2 = SWIG_AsVal_int(obj1, &val2);
22977 if (!SWIG_IsOK(ecode2)) {
22978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22979 }
22980 arg2 = static_cast< int >(val2);
22981 }
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22985 wxPyEndAllowThreads(__tstate);
22986 if (PyErr_Occurred()) SWIG_fail;
22987 }
22988 {
22989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22990 }
22991 return resultobj;
22992 fail:
22993 return NULL;
22994 }
22995
22996
22997 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj = 0;
22999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23000 int arg2 ;
23001 bool result;
23002 void *argp1 = 0 ;
23003 int res1 = 0 ;
23004 int val2 ;
23005 int ecode2 = 0 ;
23006 PyObject * obj0 = 0 ;
23007 PyObject * obj1 = 0 ;
23008 char * kwnames[] = {
23009 (char *) "self",(char *) "button", NULL
23010 };
23011
23012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23014 if (!SWIG_IsOK(res1)) {
23015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23016 }
23017 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23018 ecode2 = SWIG_AsVal_int(obj1, &val2);
23019 if (!SWIG_IsOK(ecode2)) {
23020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23021 }
23022 arg2 = static_cast< int >(val2);
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 {
23030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23031 }
23032 return resultobj;
23033 fail:
23034 return NULL;
23035 }
23036
23037
23038 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23039 PyObject *resultobj = 0;
23040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23041 int arg2 ;
23042 bool result;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 int val2 ;
23046 int ecode2 = 0 ;
23047 PyObject * obj0 = 0 ;
23048 PyObject * obj1 = 0 ;
23049 char * kwnames[] = {
23050 (char *) "self",(char *) "but", NULL
23051 };
23052
23053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23055 if (!SWIG_IsOK(res1)) {
23056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23057 }
23058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23059 ecode2 = SWIG_AsVal_int(obj1, &val2);
23060 if (!SWIG_IsOK(ecode2)) {
23061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23062 }
23063 arg2 = static_cast< int >(val2);
23064 {
23065 PyThreadState* __tstate = wxPyBeginAllowThreads();
23066 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23067 wxPyEndAllowThreads(__tstate);
23068 if (PyErr_Occurred()) SWIG_fail;
23069 }
23070 {
23071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23072 }
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *resultobj = 0;
23081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23082 int result;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 PyObject *swig_obj[1] ;
23086
23087 if (!args) SWIG_fail;
23088 swig_obj[0] = args;
23089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23092 }
23093 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 resultobj = SWIG_From_int(static_cast< int >(result));
23101 return resultobj;
23102 fail:
23103 return NULL;
23104 }
23105
23106
23107 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23108 PyObject *resultobj = 0;
23109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23110 bool result;
23111 void *argp1 = 0 ;
23112 int res1 = 0 ;
23113 PyObject *swig_obj[1] ;
23114
23115 if (!args) SWIG_fail;
23116 swig_obj[0] = args;
23117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23118 if (!SWIG_IsOK(res1)) {
23119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23120 }
23121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 {
23129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23130 }
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23138 PyObject *resultobj = 0;
23139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23140 bool result;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 PyObject *swig_obj[1] ;
23144
23145 if (!args) SWIG_fail;
23146 swig_obj[0] = args;
23147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23150 }
23151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23152 {
23153 PyThreadState* __tstate = wxPyBeginAllowThreads();
23154 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 {
23159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23160 }
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 PyObject *resultobj = 0;
23169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23170 bool result;
23171 void *argp1 = 0 ;
23172 int res1 = 0 ;
23173 PyObject *swig_obj[1] ;
23174
23175 if (!args) SWIG_fail;
23176 swig_obj[0] = args;
23177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23178 if (!SWIG_IsOK(res1)) {
23179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23180 }
23181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 {
23189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23190 }
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23198 PyObject *resultobj = 0;
23199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23200 bool result;
23201 void *argp1 = 0 ;
23202 int res1 = 0 ;
23203 PyObject *swig_obj[1] ;
23204
23205 if (!args) SWIG_fail;
23206 swig_obj[0] = args;
23207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23208 if (!SWIG_IsOK(res1)) {
23209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23210 }
23211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 {
23219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23220 }
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23228 PyObject *resultobj = 0;
23229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23230 bool result;
23231 void *argp1 = 0 ;
23232 int res1 = 0 ;
23233 PyObject *swig_obj[1] ;
23234
23235 if (!args) SWIG_fail;
23236 swig_obj[0] = args;
23237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23238 if (!SWIG_IsOK(res1)) {
23239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23240 }
23241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23245 wxPyEndAllowThreads(__tstate);
23246 if (PyErr_Occurred()) SWIG_fail;
23247 }
23248 {
23249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23250 }
23251 return resultobj;
23252 fail:
23253 return NULL;
23254 }
23255
23256
23257 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23258 PyObject *resultobj = 0;
23259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23260 bool result;
23261 void *argp1 = 0 ;
23262 int res1 = 0 ;
23263 PyObject *swig_obj[1] ;
23264
23265 if (!args) SWIG_fail;
23266 swig_obj[0] = args;
23267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23268 if (!SWIG_IsOK(res1)) {
23269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23270 }
23271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23272 {
23273 PyThreadState* __tstate = wxPyBeginAllowThreads();
23274 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23275 wxPyEndAllowThreads(__tstate);
23276 if (PyErr_Occurred()) SWIG_fail;
23277 }
23278 {
23279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23280 }
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23288 PyObject *resultobj = 0;
23289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23290 bool result;
23291 void *argp1 = 0 ;
23292 int res1 = 0 ;
23293 PyObject *swig_obj[1] ;
23294
23295 if (!args) SWIG_fail;
23296 swig_obj[0] = args;
23297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23298 if (!SWIG_IsOK(res1)) {
23299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23300 }
23301 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23305 wxPyEndAllowThreads(__tstate);
23306 if (PyErr_Occurred()) SWIG_fail;
23307 }
23308 {
23309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23310 }
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23318 PyObject *resultobj = 0;
23319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23320 bool result;
23321 void *argp1 = 0 ;
23322 int res1 = 0 ;
23323 PyObject *swig_obj[1] ;
23324
23325 if (!args) SWIG_fail;
23326 swig_obj[0] = args;
23327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23328 if (!SWIG_IsOK(res1)) {
23329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23330 }
23331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23332 {
23333 PyThreadState* __tstate = wxPyBeginAllowThreads();
23334 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 {
23339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23340 }
23341 return resultobj;
23342 fail:
23343 return NULL;
23344 }
23345
23346
23347 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23348 PyObject *resultobj = 0;
23349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23350 bool result;
23351 void *argp1 = 0 ;
23352 int res1 = 0 ;
23353 PyObject *swig_obj[1] ;
23354
23355 if (!args) SWIG_fail;
23356 swig_obj[0] = args;
23357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23358 if (!SWIG_IsOK(res1)) {
23359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23360 }
23361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23362 {
23363 PyThreadState* __tstate = wxPyBeginAllowThreads();
23364 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23365 wxPyEndAllowThreads(__tstate);
23366 if (PyErr_Occurred()) SWIG_fail;
23367 }
23368 {
23369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23370 }
23371 return resultobj;
23372 fail:
23373 return NULL;
23374 }
23375
23376
23377 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23378 PyObject *resultobj = 0;
23379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23380 bool result;
23381 void *argp1 = 0 ;
23382 int res1 = 0 ;
23383 PyObject *swig_obj[1] ;
23384
23385 if (!args) SWIG_fail;
23386 swig_obj[0] = args;
23387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23388 if (!SWIG_IsOK(res1)) {
23389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23390 }
23391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23392 {
23393 PyThreadState* __tstate = wxPyBeginAllowThreads();
23394 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 {
23399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23400 }
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23408 PyObject *resultobj = 0;
23409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23410 bool result;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 PyObject *swig_obj[1] ;
23414
23415 if (!args) SWIG_fail;
23416 swig_obj[0] = args;
23417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23418 if (!SWIG_IsOK(res1)) {
23419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23420 }
23421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23422 {
23423 PyThreadState* __tstate = wxPyBeginAllowThreads();
23424 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23425 wxPyEndAllowThreads(__tstate);
23426 if (PyErr_Occurred()) SWIG_fail;
23427 }
23428 {
23429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23430 }
23431 return resultobj;
23432 fail:
23433 return NULL;
23434 }
23435
23436
23437 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23438 PyObject *resultobj = 0;
23439 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23440 bool result;
23441 void *argp1 = 0 ;
23442 int res1 = 0 ;
23443 PyObject *swig_obj[1] ;
23444
23445 if (!args) SWIG_fail;
23446 swig_obj[0] = args;
23447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23448 if (!SWIG_IsOK(res1)) {
23449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23450 }
23451 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 {
23459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23460 }
23461 return resultobj;
23462 fail:
23463 return NULL;
23464 }
23465
23466
23467 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23468 PyObject *resultobj = 0;
23469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23470 bool result;
23471 void *argp1 = 0 ;
23472 int res1 = 0 ;
23473 PyObject *swig_obj[1] ;
23474
23475 if (!args) SWIG_fail;
23476 swig_obj[0] = args;
23477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23478 if (!SWIG_IsOK(res1)) {
23479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23480 }
23481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 {
23489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23490 }
23491 return resultobj;
23492 fail:
23493 return NULL;
23494 }
23495
23496
23497 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23498 PyObject *resultobj = 0;
23499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23500 bool result;
23501 void *argp1 = 0 ;
23502 int res1 = 0 ;
23503 PyObject *swig_obj[1] ;
23504
23505 if (!args) SWIG_fail;
23506 swig_obj[0] = args;
23507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23510 }
23511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 {
23519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23520 }
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23528 PyObject *resultobj = 0;
23529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23530 bool result;
23531 void *argp1 = 0 ;
23532 int res1 = 0 ;
23533 PyObject *swig_obj[1] ;
23534
23535 if (!args) SWIG_fail;
23536 swig_obj[0] = args;
23537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23538 if (!SWIG_IsOK(res1)) {
23539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23540 }
23541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = (bool)(arg1)->LeftIsDown();
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 {
23549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23550 }
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23558 PyObject *resultobj = 0;
23559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23560 bool result;
23561 void *argp1 = 0 ;
23562 int res1 = 0 ;
23563 PyObject *swig_obj[1] ;
23564
23565 if (!args) SWIG_fail;
23566 swig_obj[0] = args;
23567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23568 if (!SWIG_IsOK(res1)) {
23569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23570 }
23571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (bool)(arg1)->MiddleIsDown();
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23580 }
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23588 PyObject *resultobj = 0;
23589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23590 bool result;
23591 void *argp1 = 0 ;
23592 int res1 = 0 ;
23593 PyObject *swig_obj[1] ;
23594
23595 if (!args) SWIG_fail;
23596 swig_obj[0] = args;
23597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23598 if (!SWIG_IsOK(res1)) {
23599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23600 }
23601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (bool)(arg1)->RightIsDown();
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23618 PyObject *resultobj = 0;
23619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23620 bool result;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 PyObject *swig_obj[1] ;
23624
23625 if (!args) SWIG_fail;
23626 swig_obj[0] = args;
23627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23628 if (!SWIG_IsOK(res1)) {
23629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23630 }
23631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23640 }
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 PyObject *resultobj = 0;
23649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23650 bool result;
23651 void *argp1 = 0 ;
23652 int res1 = 0 ;
23653 PyObject *swig_obj[1] ;
23654
23655 if (!args) SWIG_fail;
23656 swig_obj[0] = args;
23657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23658 if (!SWIG_IsOK(res1)) {
23659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23660 }
23661 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23662 {
23663 PyThreadState* __tstate = wxPyBeginAllowThreads();
23664 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23670 }
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23680 bool result;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 PyObject *swig_obj[1] ;
23684
23685 if (!args) SWIG_fail;
23686 swig_obj[0] = args;
23687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23688 if (!SWIG_IsOK(res1)) {
23689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23690 }
23691 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 {
23699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23700 }
23701 return resultobj;
23702 fail:
23703 return NULL;
23704 }
23705
23706
23707 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23708 PyObject *resultobj = 0;
23709 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23710 bool result;
23711 void *argp1 = 0 ;
23712 int res1 = 0 ;
23713 PyObject *swig_obj[1] ;
23714
23715 if (!args) SWIG_fail;
23716 swig_obj[0] = args;
23717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23718 if (!SWIG_IsOK(res1)) {
23719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23720 }
23721 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23722 {
23723 PyThreadState* __tstate = wxPyBeginAllowThreads();
23724 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23725 wxPyEndAllowThreads(__tstate);
23726 if (PyErr_Occurred()) SWIG_fail;
23727 }
23728 {
23729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23730 }
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23738 PyObject *resultobj = 0;
23739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23740 wxPoint result;
23741 void *argp1 = 0 ;
23742 int res1 = 0 ;
23743 PyObject *swig_obj[1] ;
23744
23745 if (!args) SWIG_fail;
23746 swig_obj[0] = args;
23747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23748 if (!SWIG_IsOK(res1)) {
23749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23750 }
23751 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23752 {
23753 PyThreadState* __tstate = wxPyBeginAllowThreads();
23754 result = (arg1)->GetPosition();
23755 wxPyEndAllowThreads(__tstate);
23756 if (PyErr_Occurred()) SWIG_fail;
23757 }
23758 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23766 PyObject *resultobj = 0;
23767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23768 long *arg2 = (long *) 0 ;
23769 long *arg3 = (long *) 0 ;
23770 void *argp1 = 0 ;
23771 int res1 = 0 ;
23772 long temp2 ;
23773 int res2 = SWIG_TMPOBJ ;
23774 long temp3 ;
23775 int res3 = SWIG_TMPOBJ ;
23776 PyObject *swig_obj[1] ;
23777
23778 arg2 = &temp2;
23779 arg3 = &temp3;
23780 if (!args) SWIG_fail;
23781 swig_obj[0] = args;
23782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23783 if (!SWIG_IsOK(res1)) {
23784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23785 }
23786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 (arg1)->GetPosition(arg2,arg3);
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_Py_Void();
23794 if (SWIG_IsTmpObj(res2)) {
23795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23796 } else {
23797 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23799 }
23800 if (SWIG_IsTmpObj(res3)) {
23801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23802 } else {
23803 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23805 }
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23813 PyObject *resultobj = 0;
23814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23815 wxDC *arg2 = 0 ;
23816 wxPoint result;
23817 void *argp1 = 0 ;
23818 int res1 = 0 ;
23819 void *argp2 = 0 ;
23820 int res2 = 0 ;
23821 PyObject * obj0 = 0 ;
23822 PyObject * obj1 = 0 ;
23823 char * kwnames[] = {
23824 (char *) "self",(char *) "dc", NULL
23825 };
23826
23827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23829 if (!SWIG_IsOK(res1)) {
23830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23831 }
23832 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23834 if (!SWIG_IsOK(res2)) {
23835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23836 }
23837 if (!argp2) {
23838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23839 }
23840 arg2 = reinterpret_cast< wxDC * >(argp2);
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23844 wxPyEndAllowThreads(__tstate);
23845 if (PyErr_Occurred()) SWIG_fail;
23846 }
23847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23848 return resultobj;
23849 fail:
23850 return NULL;
23851 }
23852
23853
23854 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23855 PyObject *resultobj = 0;
23856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23857 int result;
23858 void *argp1 = 0 ;
23859 int res1 = 0 ;
23860 PyObject *swig_obj[1] ;
23861
23862 if (!args) SWIG_fail;
23863 swig_obj[0] = args;
23864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23865 if (!SWIG_IsOK(res1)) {
23866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23867 }
23868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = (int)((wxMouseEvent const *)arg1)->GetX();
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 resultobj = SWIG_From_int(static_cast< int >(result));
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *resultobj = 0;
23884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23885 int result;
23886 void *argp1 = 0 ;
23887 int res1 = 0 ;
23888 PyObject *swig_obj[1] ;
23889
23890 if (!args) SWIG_fail;
23891 swig_obj[0] = args;
23892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23893 if (!SWIG_IsOK(res1)) {
23894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23895 }
23896 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = (int)((wxMouseEvent const *)arg1)->GetY();
23900 wxPyEndAllowThreads(__tstate);
23901 if (PyErr_Occurred()) SWIG_fail;
23902 }
23903 resultobj = SWIG_From_int(static_cast< int >(result));
23904 return resultobj;
23905 fail:
23906 return NULL;
23907 }
23908
23909
23910 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23911 PyObject *resultobj = 0;
23912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23913 int result;
23914 void *argp1 = 0 ;
23915 int res1 = 0 ;
23916 PyObject *swig_obj[1] ;
23917
23918 if (!args) SWIG_fail;
23919 swig_obj[0] = args;
23920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23921 if (!SWIG_IsOK(res1)) {
23922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23923 }
23924 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23925 {
23926 PyThreadState* __tstate = wxPyBeginAllowThreads();
23927 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23928 wxPyEndAllowThreads(__tstate);
23929 if (PyErr_Occurred()) SWIG_fail;
23930 }
23931 resultobj = SWIG_From_int(static_cast< int >(result));
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23939 PyObject *resultobj = 0;
23940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23941 int result;
23942 void *argp1 = 0 ;
23943 int res1 = 0 ;
23944 PyObject *swig_obj[1] ;
23945
23946 if (!args) SWIG_fail;
23947 swig_obj[0] = args;
23948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23949 if (!SWIG_IsOK(res1)) {
23950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23951 }
23952 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23956 wxPyEndAllowThreads(__tstate);
23957 if (PyErr_Occurred()) SWIG_fail;
23958 }
23959 resultobj = SWIG_From_int(static_cast< int >(result));
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23967 PyObject *resultobj = 0;
23968 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23969 int result;
23970 void *argp1 = 0 ;
23971 int res1 = 0 ;
23972 PyObject *swig_obj[1] ;
23973
23974 if (!args) SWIG_fail;
23975 swig_obj[0] = args;
23976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23977 if (!SWIG_IsOK(res1)) {
23978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23979 }
23980 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23981 {
23982 PyThreadState* __tstate = wxPyBeginAllowThreads();
23983 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23984 wxPyEndAllowThreads(__tstate);
23985 if (PyErr_Occurred()) SWIG_fail;
23986 }
23987 resultobj = SWIG_From_int(static_cast< int >(result));
23988 return resultobj;
23989 fail:
23990 return NULL;
23991 }
23992
23993
23994 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23995 PyObject *resultobj = 0;
23996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23997 int result;
23998 void *argp1 = 0 ;
23999 int res1 = 0 ;
24000 PyObject *swig_obj[1] ;
24001
24002 if (!args) SWIG_fail;
24003 swig_obj[0] = args;
24004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24005 if (!SWIG_IsOK(res1)) {
24006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24007 }
24008 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24009 {
24010 PyThreadState* __tstate = wxPyBeginAllowThreads();
24011 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24012 wxPyEndAllowThreads(__tstate);
24013 if (PyErr_Occurred()) SWIG_fail;
24014 }
24015 resultobj = SWIG_From_int(static_cast< int >(result));
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24023 PyObject *resultobj = 0;
24024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24025 bool result;
24026 void *argp1 = 0 ;
24027 int res1 = 0 ;
24028 PyObject *swig_obj[1] ;
24029
24030 if (!args) SWIG_fail;
24031 swig_obj[0] = args;
24032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24033 if (!SWIG_IsOK(res1)) {
24034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24035 }
24036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24040 wxPyEndAllowThreads(__tstate);
24041 if (PyErr_Occurred()) SWIG_fail;
24042 }
24043 {
24044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24045 }
24046 return resultobj;
24047 fail:
24048 return NULL;
24049 }
24050
24051
24052 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24053 PyObject *resultobj = 0;
24054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24055 int arg2 ;
24056 void *argp1 = 0 ;
24057 int res1 = 0 ;
24058 int val2 ;
24059 int ecode2 = 0 ;
24060 PyObject *swig_obj[2] ;
24061
24062 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24064 if (!SWIG_IsOK(res1)) {
24065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24066 }
24067 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24068 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24069 if (!SWIG_IsOK(ecode2)) {
24070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24071 }
24072 arg2 = static_cast< int >(val2);
24073 if (arg1) (arg1)->m_x = arg2;
24074
24075 resultobj = SWIG_Py_Void();
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24083 PyObject *resultobj = 0;
24084 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24085 int result;
24086 void *argp1 = 0 ;
24087 int res1 = 0 ;
24088 PyObject *swig_obj[1] ;
24089
24090 if (!args) SWIG_fail;
24091 swig_obj[0] = args;
24092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24093 if (!SWIG_IsOK(res1)) {
24094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24095 }
24096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24097 result = (int) ((arg1)->m_x);
24098 resultobj = SWIG_From_int(static_cast< int >(result));
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24106 PyObject *resultobj = 0;
24107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24108 int arg2 ;
24109 void *argp1 = 0 ;
24110 int res1 = 0 ;
24111 int val2 ;
24112 int ecode2 = 0 ;
24113 PyObject *swig_obj[2] ;
24114
24115 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24117 if (!SWIG_IsOK(res1)) {
24118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24119 }
24120 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24121 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24122 if (!SWIG_IsOK(ecode2)) {
24123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24124 }
24125 arg2 = static_cast< int >(val2);
24126 if (arg1) (arg1)->m_y = arg2;
24127
24128 resultobj = SWIG_Py_Void();
24129 return resultobj;
24130 fail:
24131 return NULL;
24132 }
24133
24134
24135 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24136 PyObject *resultobj = 0;
24137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24138 int result;
24139 void *argp1 = 0 ;
24140 int res1 = 0 ;
24141 PyObject *swig_obj[1] ;
24142
24143 if (!args) SWIG_fail;
24144 swig_obj[0] = args;
24145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24146 if (!SWIG_IsOK(res1)) {
24147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24148 }
24149 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24150 result = (int) ((arg1)->m_y);
24151 resultobj = SWIG_From_int(static_cast< int >(result));
24152 return resultobj;
24153 fail:
24154 return NULL;
24155 }
24156
24157
24158 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24159 PyObject *resultobj = 0;
24160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24161 bool arg2 ;
24162 void *argp1 = 0 ;
24163 int res1 = 0 ;
24164 bool val2 ;
24165 int ecode2 = 0 ;
24166 PyObject *swig_obj[2] ;
24167
24168 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24170 if (!SWIG_IsOK(res1)) {
24171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24172 }
24173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24174 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24175 if (!SWIG_IsOK(ecode2)) {
24176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24177 }
24178 arg2 = static_cast< bool >(val2);
24179 if (arg1) (arg1)->m_leftDown = arg2;
24180
24181 resultobj = SWIG_Py_Void();
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24189 PyObject *resultobj = 0;
24190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24191 bool result;
24192 void *argp1 = 0 ;
24193 int res1 = 0 ;
24194 PyObject *swig_obj[1] ;
24195
24196 if (!args) SWIG_fail;
24197 swig_obj[0] = args;
24198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24199 if (!SWIG_IsOK(res1)) {
24200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24201 }
24202 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24203 result = (bool) ((arg1)->m_leftDown);
24204 {
24205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24206 }
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *resultobj = 0;
24215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24216 bool arg2 ;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 bool val2 ;
24220 int ecode2 = 0 ;
24221 PyObject *swig_obj[2] ;
24222
24223 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24225 if (!SWIG_IsOK(res1)) {
24226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24227 }
24228 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24229 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24230 if (!SWIG_IsOK(ecode2)) {
24231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24232 }
24233 arg2 = static_cast< bool >(val2);
24234 if (arg1) (arg1)->m_middleDown = arg2;
24235
24236 resultobj = SWIG_Py_Void();
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24244 PyObject *resultobj = 0;
24245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24246 bool result;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 PyObject *swig_obj[1] ;
24250
24251 if (!args) SWIG_fail;
24252 swig_obj[0] = args;
24253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24254 if (!SWIG_IsOK(res1)) {
24255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24256 }
24257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24258 result = (bool) ((arg1)->m_middleDown);
24259 {
24260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24261 }
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24269 PyObject *resultobj = 0;
24270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24271 bool arg2 ;
24272 void *argp1 = 0 ;
24273 int res1 = 0 ;
24274 bool val2 ;
24275 int ecode2 = 0 ;
24276 PyObject *swig_obj[2] ;
24277
24278 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24280 if (!SWIG_IsOK(res1)) {
24281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24282 }
24283 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24284 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24285 if (!SWIG_IsOK(ecode2)) {
24286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24287 }
24288 arg2 = static_cast< bool >(val2);
24289 if (arg1) (arg1)->m_rightDown = arg2;
24290
24291 resultobj = SWIG_Py_Void();
24292 return resultobj;
24293 fail:
24294 return NULL;
24295 }
24296
24297
24298 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24299 PyObject *resultobj = 0;
24300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24301 bool result;
24302 void *argp1 = 0 ;
24303 int res1 = 0 ;
24304 PyObject *swig_obj[1] ;
24305
24306 if (!args) SWIG_fail;
24307 swig_obj[0] = args;
24308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24309 if (!SWIG_IsOK(res1)) {
24310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24311 }
24312 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24313 result = (bool) ((arg1)->m_rightDown);
24314 {
24315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24316 }
24317 return resultobj;
24318 fail:
24319 return NULL;
24320 }
24321
24322
24323 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24324 PyObject *resultobj = 0;
24325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24326 bool arg2 ;
24327 void *argp1 = 0 ;
24328 int res1 = 0 ;
24329 bool val2 ;
24330 int ecode2 = 0 ;
24331 PyObject *swig_obj[2] ;
24332
24333 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24335 if (!SWIG_IsOK(res1)) {
24336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24337 }
24338 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24339 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24340 if (!SWIG_IsOK(ecode2)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24342 }
24343 arg2 = static_cast< bool >(val2);
24344 if (arg1) (arg1)->m_controlDown = arg2;
24345
24346 resultobj = SWIG_Py_Void();
24347 return resultobj;
24348 fail:
24349 return NULL;
24350 }
24351
24352
24353 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24354 PyObject *resultobj = 0;
24355 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24356 bool result;
24357 void *argp1 = 0 ;
24358 int res1 = 0 ;
24359 PyObject *swig_obj[1] ;
24360
24361 if (!args) SWIG_fail;
24362 swig_obj[0] = args;
24363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24364 if (!SWIG_IsOK(res1)) {
24365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24366 }
24367 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24368 result = (bool) ((arg1)->m_controlDown);
24369 {
24370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24371 }
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24379 PyObject *resultobj = 0;
24380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24381 bool arg2 ;
24382 void *argp1 = 0 ;
24383 int res1 = 0 ;
24384 bool val2 ;
24385 int ecode2 = 0 ;
24386 PyObject *swig_obj[2] ;
24387
24388 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24390 if (!SWIG_IsOK(res1)) {
24391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24392 }
24393 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24394 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24395 if (!SWIG_IsOK(ecode2)) {
24396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24397 }
24398 arg2 = static_cast< bool >(val2);
24399 if (arg1) (arg1)->m_shiftDown = arg2;
24400
24401 resultobj = SWIG_Py_Void();
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24409 PyObject *resultobj = 0;
24410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24411 bool result;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 PyObject *swig_obj[1] ;
24415
24416 if (!args) SWIG_fail;
24417 swig_obj[0] = args;
24418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24419 if (!SWIG_IsOK(res1)) {
24420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24421 }
24422 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24423 result = (bool) ((arg1)->m_shiftDown);
24424 {
24425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24426 }
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24434 PyObject *resultobj = 0;
24435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24436 bool arg2 ;
24437 void *argp1 = 0 ;
24438 int res1 = 0 ;
24439 bool val2 ;
24440 int ecode2 = 0 ;
24441 PyObject *swig_obj[2] ;
24442
24443 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24445 if (!SWIG_IsOK(res1)) {
24446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24447 }
24448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24449 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24450 if (!SWIG_IsOK(ecode2)) {
24451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24452 }
24453 arg2 = static_cast< bool >(val2);
24454 if (arg1) (arg1)->m_altDown = arg2;
24455
24456 resultobj = SWIG_Py_Void();
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24464 PyObject *resultobj = 0;
24465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24466 bool result;
24467 void *argp1 = 0 ;
24468 int res1 = 0 ;
24469 PyObject *swig_obj[1] ;
24470
24471 if (!args) SWIG_fail;
24472 swig_obj[0] = args;
24473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24474 if (!SWIG_IsOK(res1)) {
24475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24476 }
24477 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24478 result = (bool) ((arg1)->m_altDown);
24479 {
24480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24481 }
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *resultobj = 0;
24490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24491 bool arg2 ;
24492 void *argp1 = 0 ;
24493 int res1 = 0 ;
24494 bool val2 ;
24495 int ecode2 = 0 ;
24496 PyObject *swig_obj[2] ;
24497
24498 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24500 if (!SWIG_IsOK(res1)) {
24501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24502 }
24503 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24504 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24505 if (!SWIG_IsOK(ecode2)) {
24506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24507 }
24508 arg2 = static_cast< bool >(val2);
24509 if (arg1) (arg1)->m_metaDown = arg2;
24510
24511 resultobj = SWIG_Py_Void();
24512 return resultobj;
24513 fail:
24514 return NULL;
24515 }
24516
24517
24518 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24519 PyObject *resultobj = 0;
24520 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24521 bool result;
24522 void *argp1 = 0 ;
24523 int res1 = 0 ;
24524 PyObject *swig_obj[1] ;
24525
24526 if (!args) SWIG_fail;
24527 swig_obj[0] = args;
24528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24529 if (!SWIG_IsOK(res1)) {
24530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24531 }
24532 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24533 result = (bool) ((arg1)->m_metaDown);
24534 {
24535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24536 }
24537 return resultobj;
24538 fail:
24539 return NULL;
24540 }
24541
24542
24543 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24544 PyObject *resultobj = 0;
24545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24546 int arg2 ;
24547 void *argp1 = 0 ;
24548 int res1 = 0 ;
24549 int val2 ;
24550 int ecode2 = 0 ;
24551 PyObject *swig_obj[2] ;
24552
24553 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24555 if (!SWIG_IsOK(res1)) {
24556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24557 }
24558 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24559 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24560 if (!SWIG_IsOK(ecode2)) {
24561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24562 }
24563 arg2 = static_cast< int >(val2);
24564 if (arg1) (arg1)->m_wheelRotation = arg2;
24565
24566 resultobj = SWIG_Py_Void();
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24574 PyObject *resultobj = 0;
24575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24576 int result;
24577 void *argp1 = 0 ;
24578 int res1 = 0 ;
24579 PyObject *swig_obj[1] ;
24580
24581 if (!args) SWIG_fail;
24582 swig_obj[0] = args;
24583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24584 if (!SWIG_IsOK(res1)) {
24585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24586 }
24587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24588 result = (int) ((arg1)->m_wheelRotation);
24589 resultobj = SWIG_From_int(static_cast< int >(result));
24590 return resultobj;
24591 fail:
24592 return NULL;
24593 }
24594
24595
24596 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24597 PyObject *resultobj = 0;
24598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24599 int arg2 ;
24600 void *argp1 = 0 ;
24601 int res1 = 0 ;
24602 int val2 ;
24603 int ecode2 = 0 ;
24604 PyObject *swig_obj[2] ;
24605
24606 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24608 if (!SWIG_IsOK(res1)) {
24609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24610 }
24611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24612 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24613 if (!SWIG_IsOK(ecode2)) {
24614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24615 }
24616 arg2 = static_cast< int >(val2);
24617 if (arg1) (arg1)->m_wheelDelta = arg2;
24618
24619 resultobj = SWIG_Py_Void();
24620 return resultobj;
24621 fail:
24622 return NULL;
24623 }
24624
24625
24626 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24627 PyObject *resultobj = 0;
24628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24629 int result;
24630 void *argp1 = 0 ;
24631 int res1 = 0 ;
24632 PyObject *swig_obj[1] ;
24633
24634 if (!args) SWIG_fail;
24635 swig_obj[0] = args;
24636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24637 if (!SWIG_IsOK(res1)) {
24638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24639 }
24640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24641 result = (int) ((arg1)->m_wheelDelta);
24642 resultobj = SWIG_From_int(static_cast< int >(result));
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24650 PyObject *resultobj = 0;
24651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24652 int arg2 ;
24653 void *argp1 = 0 ;
24654 int res1 = 0 ;
24655 int val2 ;
24656 int ecode2 = 0 ;
24657 PyObject *swig_obj[2] ;
24658
24659 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24661 if (!SWIG_IsOK(res1)) {
24662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24663 }
24664 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24665 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24666 if (!SWIG_IsOK(ecode2)) {
24667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24668 }
24669 arg2 = static_cast< int >(val2);
24670 if (arg1) (arg1)->m_linesPerAction = arg2;
24671
24672 resultobj = SWIG_Py_Void();
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24680 PyObject *resultobj = 0;
24681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24682 int result;
24683 void *argp1 = 0 ;
24684 int res1 = 0 ;
24685 PyObject *swig_obj[1] ;
24686
24687 if (!args) SWIG_fail;
24688 swig_obj[0] = args;
24689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24690 if (!SWIG_IsOK(res1)) {
24691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24692 }
24693 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24694 result = (int) ((arg1)->m_linesPerAction);
24695 resultobj = SWIG_From_int(static_cast< int >(result));
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24703 PyObject *obj;
24704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24705 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24706 return SWIG_Py_Void();
24707 }
24708
24709 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 return SWIG_Python_InitShadowInstance(args);
24711 }
24712
24713 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24714 PyObject *resultobj = 0;
24715 int arg1 = (int) 0 ;
24716 int arg2 = (int) 0 ;
24717 wxSetCursorEvent *result = 0 ;
24718 int val1 ;
24719 int ecode1 = 0 ;
24720 int val2 ;
24721 int ecode2 = 0 ;
24722 PyObject * obj0 = 0 ;
24723 PyObject * obj1 = 0 ;
24724 char * kwnames[] = {
24725 (char *) "x",(char *) "y", NULL
24726 };
24727
24728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24729 if (obj0) {
24730 ecode1 = SWIG_AsVal_int(obj0, &val1);
24731 if (!SWIG_IsOK(ecode1)) {
24732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24733 }
24734 arg1 = static_cast< int >(val1);
24735 }
24736 if (obj1) {
24737 ecode2 = SWIG_AsVal_int(obj1, &val2);
24738 if (!SWIG_IsOK(ecode2)) {
24739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24740 }
24741 arg2 = static_cast< int >(val2);
24742 }
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24746 wxPyEndAllowThreads(__tstate);
24747 if (PyErr_Occurred()) SWIG_fail;
24748 }
24749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *resultobj = 0;
24758 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24759 int result;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 PyObject *swig_obj[1] ;
24763
24764 if (!args) SWIG_fail;
24765 swig_obj[0] = args;
24766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24767 if (!SWIG_IsOK(res1)) {
24768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24769 }
24770 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 resultobj = SWIG_From_int(static_cast< int >(result));
24778 return resultobj;
24779 fail:
24780 return NULL;
24781 }
24782
24783
24784 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24785 PyObject *resultobj = 0;
24786 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24787 int result;
24788 void *argp1 = 0 ;
24789 int res1 = 0 ;
24790 PyObject *swig_obj[1] ;
24791
24792 if (!args) SWIG_fail;
24793 swig_obj[0] = args;
24794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24795 if (!SWIG_IsOK(res1)) {
24796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24797 }
24798 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 resultobj = SWIG_From_int(static_cast< int >(result));
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24813 PyObject *resultobj = 0;
24814 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24815 wxCursor *arg2 = 0 ;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 void *argp2 = 0 ;
24819 int res2 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 char * kwnames[] = {
24823 (char *) "self",(char *) "cursor", NULL
24824 };
24825
24826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24828 if (!SWIG_IsOK(res1)) {
24829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24830 }
24831 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24832 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24833 if (!SWIG_IsOK(res2)) {
24834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24835 }
24836 if (!argp2) {
24837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24838 }
24839 arg2 = reinterpret_cast< wxCursor * >(argp2);
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 (arg1)->SetCursor((wxCursor const &)*arg2);
24843 wxPyEndAllowThreads(__tstate);
24844 if (PyErr_Occurred()) SWIG_fail;
24845 }
24846 resultobj = SWIG_Py_Void();
24847 return resultobj;
24848 fail:
24849 return NULL;
24850 }
24851
24852
24853 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24854 PyObject *resultobj = 0;
24855 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24856 wxCursor *result = 0 ;
24857 void *argp1 = 0 ;
24858 int res1 = 0 ;
24859 PyObject *swig_obj[1] ;
24860
24861 if (!args) SWIG_fail;
24862 swig_obj[0] = args;
24863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24864 if (!SWIG_IsOK(res1)) {
24865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24866 }
24867 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 {
24871 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24872 result = (wxCursor *) &_result_ref;
24873 }
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 {
24878 wxCursor* resultptr = new wxCursor(*result);
24879 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24880 }
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24888 PyObject *resultobj = 0;
24889 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24890 bool result;
24891 void *argp1 = 0 ;
24892 int res1 = 0 ;
24893 PyObject *swig_obj[1] ;
24894
24895 if (!args) SWIG_fail;
24896 swig_obj[0] = args;
24897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24900 }
24901 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24902 {
24903 PyThreadState* __tstate = wxPyBeginAllowThreads();
24904 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24905 wxPyEndAllowThreads(__tstate);
24906 if (PyErr_Occurred()) SWIG_fail;
24907 }
24908 {
24909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24910 }
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *obj;
24919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24920 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24921 return SWIG_Py_Void();
24922 }
24923
24924 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24925 return SWIG_Python_InitShadowInstance(args);
24926 }
24927
24928 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24931 wxKeyEvent *result = 0 ;
24932 int val1 ;
24933 int ecode1 = 0 ;
24934 PyObject * obj0 = 0 ;
24935 char * kwnames[] = {
24936 (char *) "eventType", NULL
24937 };
24938
24939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24940 if (obj0) {
24941 ecode1 = SWIG_AsVal_int(obj0, &val1);
24942 if (!SWIG_IsOK(ecode1)) {
24943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24944 }
24945 arg1 = static_cast< wxEventType >(val1);
24946 }
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24961 PyObject *resultobj = 0;
24962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24963 int result;
24964 void *argp1 = 0 ;
24965 int res1 = 0 ;
24966 PyObject *swig_obj[1] ;
24967
24968 if (!args) SWIG_fail;
24969 swig_obj[0] = args;
24970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24971 if (!SWIG_IsOK(res1)) {
24972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24973 }
24974 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24975 {
24976 PyThreadState* __tstate = wxPyBeginAllowThreads();
24977 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 resultobj = SWIG_From_int(static_cast< int >(result));
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24989 PyObject *resultobj = 0;
24990 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24991 bool result;
24992 void *argp1 = 0 ;
24993 int res1 = 0 ;
24994 PyObject *swig_obj[1] ;
24995
24996 if (!args) SWIG_fail;
24997 swig_obj[0] = args;
24998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24999 if (!SWIG_IsOK(res1)) {
25000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25001 }
25002 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25003 {
25004 PyThreadState* __tstate = wxPyBeginAllowThreads();
25005 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25006 wxPyEndAllowThreads(__tstate);
25007 if (PyErr_Occurred()) SWIG_fail;
25008 }
25009 {
25010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25011 }
25012 return resultobj;
25013 fail:
25014 return NULL;
25015 }
25016
25017
25018 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25019 PyObject *resultobj = 0;
25020 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25021 bool result;
25022 void *argp1 = 0 ;
25023 int res1 = 0 ;
25024 PyObject *swig_obj[1] ;
25025
25026 if (!args) SWIG_fail;
25027 swig_obj[0] = args;
25028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25029 if (!SWIG_IsOK(res1)) {
25030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25031 }
25032 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 {
25040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25041 }
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25049 PyObject *resultobj = 0;
25050 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25051 bool result;
25052 void *argp1 = 0 ;
25053 int res1 = 0 ;
25054 PyObject *swig_obj[1] ;
25055
25056 if (!args) SWIG_fail;
25057 swig_obj[0] = args;
25058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25061 }
25062 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25079 PyObject *resultobj = 0;
25080 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25081 bool result;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 PyObject *swig_obj[1] ;
25085
25086 if (!args) SWIG_fail;
25087 swig_obj[0] = args;
25088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25089 if (!SWIG_IsOK(res1)) {
25090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25091 }
25092 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 {
25100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25101 }
25102 return resultobj;
25103 fail:
25104 return NULL;
25105 }
25106
25107
25108 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25109 PyObject *resultobj = 0;
25110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25111 bool result;
25112 void *argp1 = 0 ;
25113 int res1 = 0 ;
25114 PyObject *swig_obj[1] ;
25115
25116 if (!args) SWIG_fail;
25117 swig_obj[0] = args;
25118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25119 if (!SWIG_IsOK(res1)) {
25120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25121 }
25122 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 {
25130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25131 }
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25139 PyObject *resultobj = 0;
25140 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25141 bool result;
25142 void *argp1 = 0 ;
25143 int res1 = 0 ;
25144 PyObject *swig_obj[1] ;
25145
25146 if (!args) SWIG_fail;
25147 swig_obj[0] = args;
25148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25149 if (!SWIG_IsOK(res1)) {
25150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25151 }
25152 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 {
25160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25161 }
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25169 PyObject *resultobj = 0;
25170 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25171 int result;
25172 void *argp1 = 0 ;
25173 int res1 = 0 ;
25174 PyObject *swig_obj[1] ;
25175
25176 if (!args) SWIG_fail;
25177 swig_obj[0] = args;
25178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25179 if (!SWIG_IsOK(res1)) {
25180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25181 }
25182 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 resultobj = SWIG_From_int(static_cast< int >(result));
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *resultobj = 0;
25198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25199 int result;
25200 void *argp1 = 0 ;
25201 int res1 = 0 ;
25202 PyObject *swig_obj[1] ;
25203
25204 if (!args) SWIG_fail;
25205 swig_obj[0] = args;
25206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25207 if (!SWIG_IsOK(res1)) {
25208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25209 }
25210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 resultobj = SWIG_From_int(static_cast< int >(result));
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj = 0;
25226 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25227 int arg2 ;
25228 void *argp1 = 0 ;
25229 int res1 = 0 ;
25230 int val2 ;
25231 int ecode2 = 0 ;
25232 PyObject * obj0 = 0 ;
25233 PyObject * obj1 = 0 ;
25234 char * kwnames[] = {
25235 (char *) "self",(char *) "uniChar", NULL
25236 };
25237
25238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25240 if (!SWIG_IsOK(res1)) {
25241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25242 }
25243 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25244 ecode2 = SWIG_AsVal_int(obj1, &val2);
25245 if (!SWIG_IsOK(ecode2)) {
25246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25247 }
25248 arg2 = static_cast< int >(val2);
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 resultobj = SWIG_Py_Void();
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25263 PyObject *resultobj = 0;
25264 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25265 unsigned int result;
25266 void *argp1 = 0 ;
25267 int res1 = 0 ;
25268 PyObject *swig_obj[1] ;
25269
25270 if (!args) SWIG_fail;
25271 swig_obj[0] = args;
25272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25273 if (!SWIG_IsOK(res1)) {
25274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25275 }
25276 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25277 {
25278 PyThreadState* __tstate = wxPyBeginAllowThreads();
25279 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25280 wxPyEndAllowThreads(__tstate);
25281 if (PyErr_Occurred()) SWIG_fail;
25282 }
25283 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25284 return resultobj;
25285 fail:
25286 return NULL;
25287 }
25288
25289
25290 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25291 PyObject *resultobj = 0;
25292 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25293 unsigned int result;
25294 void *argp1 = 0 ;
25295 int res1 = 0 ;
25296 PyObject *swig_obj[1] ;
25297
25298 if (!args) SWIG_fail;
25299 swig_obj[0] = args;
25300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25301 if (!SWIG_IsOK(res1)) {
25302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25303 }
25304 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25305 {
25306 PyThreadState* __tstate = wxPyBeginAllowThreads();
25307 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25308 wxPyEndAllowThreads(__tstate);
25309 if (PyErr_Occurred()) SWIG_fail;
25310 }
25311 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25319 PyObject *resultobj = 0;
25320 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25321 wxPoint result;
25322 void *argp1 = 0 ;
25323 int res1 = 0 ;
25324 PyObject *swig_obj[1] ;
25325
25326 if (!args) SWIG_fail;
25327 swig_obj[0] = args;
25328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25329 if (!SWIG_IsOK(res1)) {
25330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25331 }
25332 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (arg1)->GetPosition();
25336 wxPyEndAllowThreads(__tstate);
25337 if (PyErr_Occurred()) SWIG_fail;
25338 }
25339 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 PyObject *resultobj = 0;
25348 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25349 long *arg2 = (long *) 0 ;
25350 long *arg3 = (long *) 0 ;
25351 void *argp1 = 0 ;
25352 int res1 = 0 ;
25353 long temp2 ;
25354 int res2 = SWIG_TMPOBJ ;
25355 long temp3 ;
25356 int res3 = SWIG_TMPOBJ ;
25357 PyObject *swig_obj[1] ;
25358
25359 arg2 = &temp2;
25360 arg3 = &temp3;
25361 if (!args) SWIG_fail;
25362 swig_obj[0] = args;
25363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25364 if (!SWIG_IsOK(res1)) {
25365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25366 }
25367 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 (arg1)->GetPosition(arg2,arg3);
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_Py_Void();
25375 if (SWIG_IsTmpObj(res2)) {
25376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25377 } else {
25378 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25380 }
25381 if (SWIG_IsTmpObj(res3)) {
25382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25383 } else {
25384 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25386 }
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25394 PyObject *resultobj = 0;
25395 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25396 int result;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 PyObject *swig_obj[1] ;
25400
25401 if (!args) SWIG_fail;
25402 swig_obj[0] = args;
25403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25404 if (!SWIG_IsOK(res1)) {
25405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25406 }
25407 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 result = (int)((wxKeyEvent const *)arg1)->GetX();
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_From_int(static_cast< int >(result));
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25422 PyObject *resultobj = 0;
25423 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25424 int result;
25425 void *argp1 = 0 ;
25426 int res1 = 0 ;
25427 PyObject *swig_obj[1] ;
25428
25429 if (!args) SWIG_fail;
25430 swig_obj[0] = args;
25431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25432 if (!SWIG_IsOK(res1)) {
25433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25434 }
25435 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (int)((wxKeyEvent const *)arg1)->GetY();
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_From_int(static_cast< int >(result));
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25450 PyObject *resultobj = 0;
25451 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25452 int arg2 ;
25453 void *argp1 = 0 ;
25454 int res1 = 0 ;
25455 int val2 ;
25456 int ecode2 = 0 ;
25457 PyObject *swig_obj[2] ;
25458
25459 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25461 if (!SWIG_IsOK(res1)) {
25462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25463 }
25464 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25465 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25466 if (!SWIG_IsOK(ecode2)) {
25467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25468 }
25469 arg2 = static_cast< int >(val2);
25470 if (arg1) (arg1)->m_x = arg2;
25471
25472 resultobj = SWIG_Py_Void();
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25480 PyObject *resultobj = 0;
25481 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25482 int result;
25483 void *argp1 = 0 ;
25484 int res1 = 0 ;
25485 PyObject *swig_obj[1] ;
25486
25487 if (!args) SWIG_fail;
25488 swig_obj[0] = args;
25489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25490 if (!SWIG_IsOK(res1)) {
25491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25492 }
25493 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25494 result = (int) ((arg1)->m_x);
25495 resultobj = SWIG_From_int(static_cast< int >(result));
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25503 PyObject *resultobj = 0;
25504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25505 int arg2 ;
25506 void *argp1 = 0 ;
25507 int res1 = 0 ;
25508 int val2 ;
25509 int ecode2 = 0 ;
25510 PyObject *swig_obj[2] ;
25511
25512 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25514 if (!SWIG_IsOK(res1)) {
25515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25516 }
25517 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25518 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25519 if (!SWIG_IsOK(ecode2)) {
25520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25521 }
25522 arg2 = static_cast< int >(val2);
25523 if (arg1) (arg1)->m_y = arg2;
25524
25525 resultobj = SWIG_Py_Void();
25526 return resultobj;
25527 fail:
25528 return NULL;
25529 }
25530
25531
25532 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25533 PyObject *resultobj = 0;
25534 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25535 int result;
25536 void *argp1 = 0 ;
25537 int res1 = 0 ;
25538 PyObject *swig_obj[1] ;
25539
25540 if (!args) SWIG_fail;
25541 swig_obj[0] = args;
25542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25543 if (!SWIG_IsOK(res1)) {
25544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25545 }
25546 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25547 result = (int) ((arg1)->m_y);
25548 resultobj = SWIG_From_int(static_cast< int >(result));
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25556 PyObject *resultobj = 0;
25557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25558 long arg2 ;
25559 void *argp1 = 0 ;
25560 int res1 = 0 ;
25561 long val2 ;
25562 int ecode2 = 0 ;
25563 PyObject *swig_obj[2] ;
25564
25565 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25567 if (!SWIG_IsOK(res1)) {
25568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25569 }
25570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25571 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25572 if (!SWIG_IsOK(ecode2)) {
25573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25574 }
25575 arg2 = static_cast< long >(val2);
25576 if (arg1) (arg1)->m_keyCode = arg2;
25577
25578 resultobj = SWIG_Py_Void();
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25586 PyObject *resultobj = 0;
25587 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25588 long result;
25589 void *argp1 = 0 ;
25590 int res1 = 0 ;
25591 PyObject *swig_obj[1] ;
25592
25593 if (!args) SWIG_fail;
25594 swig_obj[0] = args;
25595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25596 if (!SWIG_IsOK(res1)) {
25597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25598 }
25599 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25600 result = (long) ((arg1)->m_keyCode);
25601 resultobj = SWIG_From_long(static_cast< long >(result));
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25609 PyObject *resultobj = 0;
25610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25611 bool arg2 ;
25612 void *argp1 = 0 ;
25613 int res1 = 0 ;
25614 bool val2 ;
25615 int ecode2 = 0 ;
25616 PyObject *swig_obj[2] ;
25617
25618 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25620 if (!SWIG_IsOK(res1)) {
25621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25622 }
25623 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25624 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25625 if (!SWIG_IsOK(ecode2)) {
25626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25627 }
25628 arg2 = static_cast< bool >(val2);
25629 if (arg1) (arg1)->m_controlDown = arg2;
25630
25631 resultobj = SWIG_Py_Void();
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25639 PyObject *resultobj = 0;
25640 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25641 bool result;
25642 void *argp1 = 0 ;
25643 int res1 = 0 ;
25644 PyObject *swig_obj[1] ;
25645
25646 if (!args) SWIG_fail;
25647 swig_obj[0] = args;
25648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25649 if (!SWIG_IsOK(res1)) {
25650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25651 }
25652 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25653 result = (bool) ((arg1)->m_controlDown);
25654 {
25655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25656 }
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25664 PyObject *resultobj = 0;
25665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25666 bool arg2 ;
25667 void *argp1 = 0 ;
25668 int res1 = 0 ;
25669 bool val2 ;
25670 int ecode2 = 0 ;
25671 PyObject *swig_obj[2] ;
25672
25673 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25675 if (!SWIG_IsOK(res1)) {
25676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25677 }
25678 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25679 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25680 if (!SWIG_IsOK(ecode2)) {
25681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25682 }
25683 arg2 = static_cast< bool >(val2);
25684 if (arg1) (arg1)->m_shiftDown = arg2;
25685
25686 resultobj = SWIG_Py_Void();
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25694 PyObject *resultobj = 0;
25695 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25696 bool result;
25697 void *argp1 = 0 ;
25698 int res1 = 0 ;
25699 PyObject *swig_obj[1] ;
25700
25701 if (!args) SWIG_fail;
25702 swig_obj[0] = args;
25703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25704 if (!SWIG_IsOK(res1)) {
25705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25706 }
25707 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25708 result = (bool) ((arg1)->m_shiftDown);
25709 {
25710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25711 }
25712 return resultobj;
25713 fail:
25714 return NULL;
25715 }
25716
25717
25718 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25719 PyObject *resultobj = 0;
25720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25721 bool arg2 ;
25722 void *argp1 = 0 ;
25723 int res1 = 0 ;
25724 bool val2 ;
25725 int ecode2 = 0 ;
25726 PyObject *swig_obj[2] ;
25727
25728 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25730 if (!SWIG_IsOK(res1)) {
25731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25732 }
25733 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25734 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25735 if (!SWIG_IsOK(ecode2)) {
25736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25737 }
25738 arg2 = static_cast< bool >(val2);
25739 if (arg1) (arg1)->m_altDown = arg2;
25740
25741 resultobj = SWIG_Py_Void();
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25749 PyObject *resultobj = 0;
25750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25751 bool result;
25752 void *argp1 = 0 ;
25753 int res1 = 0 ;
25754 PyObject *swig_obj[1] ;
25755
25756 if (!args) SWIG_fail;
25757 swig_obj[0] = args;
25758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25759 if (!SWIG_IsOK(res1)) {
25760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25761 }
25762 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25763 result = (bool) ((arg1)->m_altDown);
25764 {
25765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25766 }
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25774 PyObject *resultobj = 0;
25775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25776 bool arg2 ;
25777 void *argp1 = 0 ;
25778 int res1 = 0 ;
25779 bool val2 ;
25780 int ecode2 = 0 ;
25781 PyObject *swig_obj[2] ;
25782
25783 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25787 }
25788 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25789 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25790 if (!SWIG_IsOK(ecode2)) {
25791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25792 }
25793 arg2 = static_cast< bool >(val2);
25794 if (arg1) (arg1)->m_metaDown = arg2;
25795
25796 resultobj = SWIG_Py_Void();
25797 return resultobj;
25798 fail:
25799 return NULL;
25800 }
25801
25802
25803 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25804 PyObject *resultobj = 0;
25805 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25806 bool result;
25807 void *argp1 = 0 ;
25808 int res1 = 0 ;
25809 PyObject *swig_obj[1] ;
25810
25811 if (!args) SWIG_fail;
25812 swig_obj[0] = args;
25813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25814 if (!SWIG_IsOK(res1)) {
25815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25816 }
25817 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25818 result = (bool) ((arg1)->m_metaDown);
25819 {
25820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25821 }
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 PyObject *resultobj = 0;
25830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25831 bool arg2 ;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 bool val2 ;
25835 int ecode2 = 0 ;
25836 PyObject *swig_obj[2] ;
25837
25838 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25840 if (!SWIG_IsOK(res1)) {
25841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25842 }
25843 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25844 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25845 if (!SWIG_IsOK(ecode2)) {
25846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25847 }
25848 arg2 = static_cast< bool >(val2);
25849 if (arg1) (arg1)->m_scanCode = arg2;
25850
25851 resultobj = SWIG_Py_Void();
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25859 PyObject *resultobj = 0;
25860 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25861 bool result;
25862 void *argp1 = 0 ;
25863 int res1 = 0 ;
25864 PyObject *swig_obj[1] ;
25865
25866 if (!args) SWIG_fail;
25867 swig_obj[0] = args;
25868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25869 if (!SWIG_IsOK(res1)) {
25870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25871 }
25872 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25873 result = (bool) ((arg1)->m_scanCode);
25874 {
25875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25876 }
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25884 PyObject *resultobj = 0;
25885 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25886 unsigned int arg2 ;
25887 void *argp1 = 0 ;
25888 int res1 = 0 ;
25889 unsigned int val2 ;
25890 int ecode2 = 0 ;
25891 PyObject *swig_obj[2] ;
25892
25893 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25895 if (!SWIG_IsOK(res1)) {
25896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25897 }
25898 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25899 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25900 if (!SWIG_IsOK(ecode2)) {
25901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25902 }
25903 arg2 = static_cast< unsigned int >(val2);
25904 if (arg1) (arg1)->m_rawCode = arg2;
25905
25906 resultobj = SWIG_Py_Void();
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25914 PyObject *resultobj = 0;
25915 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25916 unsigned int result;
25917 void *argp1 = 0 ;
25918 int res1 = 0 ;
25919 PyObject *swig_obj[1] ;
25920
25921 if (!args) SWIG_fail;
25922 swig_obj[0] = args;
25923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25924 if (!SWIG_IsOK(res1)) {
25925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25926 }
25927 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25928 result = (unsigned int) ((arg1)->m_rawCode);
25929 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25937 PyObject *resultobj = 0;
25938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25939 unsigned int arg2 ;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 unsigned int val2 ;
25943 int ecode2 = 0 ;
25944 PyObject *swig_obj[2] ;
25945
25946 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25948 if (!SWIG_IsOK(res1)) {
25949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25950 }
25951 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25952 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25953 if (!SWIG_IsOK(ecode2)) {
25954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25955 }
25956 arg2 = static_cast< unsigned int >(val2);
25957 if (arg1) (arg1)->m_rawFlags = arg2;
25958
25959 resultobj = SWIG_Py_Void();
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25967 PyObject *resultobj = 0;
25968 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25969 unsigned int result;
25970 void *argp1 = 0 ;
25971 int res1 = 0 ;
25972 PyObject *swig_obj[1] ;
25973
25974 if (!args) SWIG_fail;
25975 swig_obj[0] = args;
25976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25977 if (!SWIG_IsOK(res1)) {
25978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25979 }
25980 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25981 result = (unsigned int) ((arg1)->m_rawFlags);
25982 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25990 PyObject *obj;
25991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25992 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25993 return SWIG_Py_Void();
25994 }
25995
25996 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25997 return SWIG_Python_InitShadowInstance(args);
25998 }
25999
26000 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj = 0;
26002 wxSize const &arg1_defvalue = wxDefaultSize ;
26003 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26004 int arg2 = (int) 0 ;
26005 wxSizeEvent *result = 0 ;
26006 wxSize temp1 ;
26007 int val2 ;
26008 int ecode2 = 0 ;
26009 PyObject * obj0 = 0 ;
26010 PyObject * obj1 = 0 ;
26011 char * kwnames[] = {
26012 (char *) "sz",(char *) "winid", NULL
26013 };
26014
26015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26016 if (obj0) {
26017 {
26018 arg1 = &temp1;
26019 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26020 }
26021 }
26022 if (obj1) {
26023 ecode2 = SWIG_AsVal_int(obj1, &val2);
26024 if (!SWIG_IsOK(ecode2)) {
26025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26026 }
26027 arg2 = static_cast< int >(val2);
26028 }
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26043 PyObject *resultobj = 0;
26044 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26045 wxSize result;
26046 void *argp1 = 0 ;
26047 int res1 = 0 ;
26048 PyObject *swig_obj[1] ;
26049
26050 if (!args) SWIG_fail;
26051 swig_obj[0] = args;
26052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26053 if (!SWIG_IsOK(res1)) {
26054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26055 }
26056 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26057 {
26058 PyThreadState* __tstate = wxPyBeginAllowThreads();
26059 result = ((wxSizeEvent const *)arg1)->GetSize();
26060 wxPyEndAllowThreads(__tstate);
26061 if (PyErr_Occurred()) SWIG_fail;
26062 }
26063 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26071 PyObject *resultobj = 0;
26072 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26073 wxRect result;
26074 void *argp1 = 0 ;
26075 int res1 = 0 ;
26076 PyObject *swig_obj[1] ;
26077
26078 if (!args) SWIG_fail;
26079 swig_obj[0] = args;
26080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26081 if (!SWIG_IsOK(res1)) {
26082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26083 }
26084 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 result = ((wxSizeEvent const *)arg1)->GetRect();
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26099 PyObject *resultobj = 0;
26100 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26101 wxRect arg2 ;
26102 void *argp1 = 0 ;
26103 int res1 = 0 ;
26104 void *argp2 ;
26105 int res2 = 0 ;
26106 PyObject * obj0 = 0 ;
26107 PyObject * obj1 = 0 ;
26108 char * kwnames[] = {
26109 (char *) "self",(char *) "rect", NULL
26110 };
26111
26112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26114 if (!SWIG_IsOK(res1)) {
26115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26116 }
26117 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26118 {
26119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26120 if (!SWIG_IsOK(res2)) {
26121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26122 }
26123 if (!argp2) {
26124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26125 } else {
26126 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26127 arg2 = *temp;
26128 if (SWIG_IsNewObj(res2)) delete temp;
26129 }
26130 }
26131 {
26132 PyThreadState* __tstate = wxPyBeginAllowThreads();
26133 (arg1)->SetRect(arg2);
26134 wxPyEndAllowThreads(__tstate);
26135 if (PyErr_Occurred()) SWIG_fail;
26136 }
26137 resultobj = SWIG_Py_Void();
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26145 PyObject *resultobj = 0;
26146 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26147 wxSize arg2 ;
26148 void *argp1 = 0 ;
26149 int res1 = 0 ;
26150 void *argp2 ;
26151 int res2 = 0 ;
26152 PyObject * obj0 = 0 ;
26153 PyObject * obj1 = 0 ;
26154 char * kwnames[] = {
26155 (char *) "self",(char *) "size", NULL
26156 };
26157
26158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26160 if (!SWIG_IsOK(res1)) {
26161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26162 }
26163 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26164 {
26165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26166 if (!SWIG_IsOK(res2)) {
26167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26168 }
26169 if (!argp2) {
26170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26171 } else {
26172 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26173 arg2 = *temp;
26174 if (SWIG_IsNewObj(res2)) delete temp;
26175 }
26176 }
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 wxSizeEvent_SetSize(arg1,arg2);
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 resultobj = SWIG_Py_Void();
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26191 PyObject *resultobj = 0;
26192 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26193 wxSize *arg2 = (wxSize *) 0 ;
26194 void *argp1 = 0 ;
26195 int res1 = 0 ;
26196 void *argp2 = 0 ;
26197 int res2 = 0 ;
26198 PyObject *swig_obj[2] ;
26199
26200 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26202 if (!SWIG_IsOK(res1)) {
26203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26204 }
26205 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26206 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26207 if (!SWIG_IsOK(res2)) {
26208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26209 }
26210 arg2 = reinterpret_cast< wxSize * >(argp2);
26211 if (arg1) (arg1)->m_size = *arg2;
26212
26213 resultobj = SWIG_Py_Void();
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26221 PyObject *resultobj = 0;
26222 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26223 wxSize *result = 0 ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 PyObject *swig_obj[1] ;
26227
26228 if (!args) SWIG_fail;
26229 swig_obj[0] = args;
26230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26231 if (!SWIG_IsOK(res1)) {
26232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26233 }
26234 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26235 result = (wxSize *)& ((arg1)->m_size);
26236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26237 return resultobj;
26238 fail:
26239 return NULL;
26240 }
26241
26242
26243 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26244 PyObject *resultobj = 0;
26245 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26246 wxRect *arg2 = (wxRect *) 0 ;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 void *argp2 = 0 ;
26250 int res2 = 0 ;
26251 PyObject *swig_obj[2] ;
26252
26253 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26255 if (!SWIG_IsOK(res1)) {
26256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26257 }
26258 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26259 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26260 if (!SWIG_IsOK(res2)) {
26261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26262 }
26263 arg2 = reinterpret_cast< wxRect * >(argp2);
26264 if (arg1) (arg1)->m_rect = *arg2;
26265
26266 resultobj = SWIG_Py_Void();
26267 return resultobj;
26268 fail:
26269 return NULL;
26270 }
26271
26272
26273 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26274 PyObject *resultobj = 0;
26275 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26276 wxRect *result = 0 ;
26277 void *argp1 = 0 ;
26278 int res1 = 0 ;
26279 PyObject *swig_obj[1] ;
26280
26281 if (!args) SWIG_fail;
26282 swig_obj[0] = args;
26283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26284 if (!SWIG_IsOK(res1)) {
26285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26286 }
26287 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26288 result = (wxRect *)& ((arg1)->m_rect);
26289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 PyObject *obj;
26298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26299 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26300 return SWIG_Py_Void();
26301 }
26302
26303 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26304 return SWIG_Python_InitShadowInstance(args);
26305 }
26306
26307 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26310 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26311 int arg2 = (int) 0 ;
26312 wxMoveEvent *result = 0 ;
26313 wxPoint temp1 ;
26314 int val2 ;
26315 int ecode2 = 0 ;
26316 PyObject * obj0 = 0 ;
26317 PyObject * obj1 = 0 ;
26318 char * kwnames[] = {
26319 (char *) "pos",(char *) "winid", NULL
26320 };
26321
26322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26323 if (obj0) {
26324 {
26325 arg1 = &temp1;
26326 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26327 }
26328 }
26329 if (obj1) {
26330 ecode2 = SWIG_AsVal_int(obj1, &val2);
26331 if (!SWIG_IsOK(ecode2)) {
26332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26333 }
26334 arg2 = static_cast< int >(val2);
26335 }
26336 {
26337 PyThreadState* __tstate = wxPyBeginAllowThreads();
26338 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26350 PyObject *resultobj = 0;
26351 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26352 wxPoint result;
26353 void *argp1 = 0 ;
26354 int res1 = 0 ;
26355 PyObject *swig_obj[1] ;
26356
26357 if (!args) SWIG_fail;
26358 swig_obj[0] = args;
26359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26360 if (!SWIG_IsOK(res1)) {
26361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26362 }
26363 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 result = ((wxMoveEvent const *)arg1)->GetPosition();
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 PyObject *resultobj = 0;
26379 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26380 wxRect result;
26381 void *argp1 = 0 ;
26382 int res1 = 0 ;
26383 PyObject *swig_obj[1] ;
26384
26385 if (!args) SWIG_fail;
26386 swig_obj[0] = args;
26387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26388 if (!SWIG_IsOK(res1)) {
26389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26390 }
26391 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = ((wxMoveEvent const *)arg1)->GetRect();
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26406 PyObject *resultobj = 0;
26407 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26408 wxRect *arg2 = 0 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 wxRect temp2 ;
26412 PyObject * obj0 = 0 ;
26413 PyObject * obj1 = 0 ;
26414 char * kwnames[] = {
26415 (char *) "self",(char *) "rect", NULL
26416 };
26417
26418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26420 if (!SWIG_IsOK(res1)) {
26421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26422 }
26423 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26424 {
26425 arg2 = &temp2;
26426 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26427 }
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 (arg1)->SetRect((wxRect const &)*arg2);
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 resultobj = SWIG_Py_Void();
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26442 PyObject *resultobj = 0;
26443 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26444 wxPoint *arg2 = 0 ;
26445 void *argp1 = 0 ;
26446 int res1 = 0 ;
26447 wxPoint temp2 ;
26448 PyObject * obj0 = 0 ;
26449 PyObject * obj1 = 0 ;
26450 char * kwnames[] = {
26451 (char *) "self",(char *) "pos", NULL
26452 };
26453
26454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26456 if (!SWIG_IsOK(res1)) {
26457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26458 }
26459 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26460 {
26461 arg2 = &temp2;
26462 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26463 }
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 (arg1)->SetPosition((wxPoint const &)*arg2);
26467 wxPyEndAllowThreads(__tstate);
26468 if (PyErr_Occurred()) SWIG_fail;
26469 }
26470 resultobj = SWIG_Py_Void();
26471 return resultobj;
26472 fail:
26473 return NULL;
26474 }
26475
26476
26477 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26478 PyObject *obj;
26479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26480 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26481 return SWIG_Py_Void();
26482 }
26483
26484 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26485 return SWIG_Python_InitShadowInstance(args);
26486 }
26487
26488 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26489 PyObject *resultobj = 0;
26490 int arg1 = (int) 0 ;
26491 wxPaintEvent *result = 0 ;
26492 int val1 ;
26493 int ecode1 = 0 ;
26494 PyObject * obj0 = 0 ;
26495 char * kwnames[] = {
26496 (char *) "Id", NULL
26497 };
26498
26499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26500 if (obj0) {
26501 ecode1 = SWIG_AsVal_int(obj0, &val1);
26502 if (!SWIG_IsOK(ecode1)) {
26503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26504 }
26505 arg1 = static_cast< int >(val1);
26506 }
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26514 return resultobj;
26515 fail:
26516 return NULL;
26517 }
26518
26519
26520 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26521 PyObject *obj;
26522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26523 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26524 return SWIG_Py_Void();
26525 }
26526
26527 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26528 return SWIG_Python_InitShadowInstance(args);
26529 }
26530
26531 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj = 0;
26533 int arg1 = (int) 0 ;
26534 wxNcPaintEvent *result = 0 ;
26535 int val1 ;
26536 int ecode1 = 0 ;
26537 PyObject * obj0 = 0 ;
26538 char * kwnames[] = {
26539 (char *) "winid", NULL
26540 };
26541
26542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26543 if (obj0) {
26544 ecode1 = SWIG_AsVal_int(obj0, &val1);
26545 if (!SWIG_IsOK(ecode1)) {
26546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26547 }
26548 arg1 = static_cast< int >(val1);
26549 }
26550 {
26551 PyThreadState* __tstate = wxPyBeginAllowThreads();
26552 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26553 wxPyEndAllowThreads(__tstate);
26554 if (PyErr_Occurred()) SWIG_fail;
26555 }
26556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26557 return resultobj;
26558 fail:
26559 return NULL;
26560 }
26561
26562
26563 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26564 PyObject *obj;
26565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26566 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26567 return SWIG_Py_Void();
26568 }
26569
26570 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26571 return SWIG_Python_InitShadowInstance(args);
26572 }
26573
26574 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26575 PyObject *resultobj = 0;
26576 int arg1 = (int) 0 ;
26577 wxDC *arg2 = (wxDC *) NULL ;
26578 wxEraseEvent *result = 0 ;
26579 int val1 ;
26580 int ecode1 = 0 ;
26581 void *argp2 = 0 ;
26582 int res2 = 0 ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 char * kwnames[] = {
26586 (char *) "Id",(char *) "dc", NULL
26587 };
26588
26589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26590 if (obj0) {
26591 ecode1 = SWIG_AsVal_int(obj0, &val1);
26592 if (!SWIG_IsOK(ecode1)) {
26593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26594 }
26595 arg1 = static_cast< int >(val1);
26596 }
26597 if (obj1) {
26598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26599 if (!SWIG_IsOK(res2)) {
26600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26601 }
26602 arg2 = reinterpret_cast< wxDC * >(argp2);
26603 }
26604 {
26605 PyThreadState* __tstate = wxPyBeginAllowThreads();
26606 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26607 wxPyEndAllowThreads(__tstate);
26608 if (PyErr_Occurred()) SWIG_fail;
26609 }
26610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26618 PyObject *resultobj = 0;
26619 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26620 wxDC *result = 0 ;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 PyObject *swig_obj[1] ;
26624
26625 if (!args) SWIG_fail;
26626 swig_obj[0] = args;
26627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26628 if (!SWIG_IsOK(res1)) {
26629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26630 }
26631 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26632 {
26633 PyThreadState* __tstate = wxPyBeginAllowThreads();
26634 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26635 wxPyEndAllowThreads(__tstate);
26636 if (PyErr_Occurred()) SWIG_fail;
26637 }
26638 {
26639 resultobj = wxPyMake_wxObject(result, (bool)0);
26640 }
26641 return resultobj;
26642 fail:
26643 return NULL;
26644 }
26645
26646
26647 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26648 PyObject *obj;
26649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26650 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26651 return SWIG_Py_Void();
26652 }
26653
26654 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26655 return SWIG_Python_InitShadowInstance(args);
26656 }
26657
26658 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26659 PyObject *resultobj = 0;
26660 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26661 int arg2 = (int) 0 ;
26662 wxFocusEvent *result = 0 ;
26663 int val1 ;
26664 int ecode1 = 0 ;
26665 int val2 ;
26666 int ecode2 = 0 ;
26667 PyObject * obj0 = 0 ;
26668 PyObject * obj1 = 0 ;
26669 char * kwnames[] = {
26670 (char *) "type",(char *) "winid", NULL
26671 };
26672
26673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26674 if (obj0) {
26675 ecode1 = SWIG_AsVal_int(obj0, &val1);
26676 if (!SWIG_IsOK(ecode1)) {
26677 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26678 }
26679 arg1 = static_cast< wxEventType >(val1);
26680 }
26681 if (obj1) {
26682 ecode2 = SWIG_AsVal_int(obj1, &val2);
26683 if (!SWIG_IsOK(ecode2)) {
26684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26685 }
26686 arg2 = static_cast< int >(val2);
26687 }
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26695 return resultobj;
26696 fail:
26697 return NULL;
26698 }
26699
26700
26701 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 PyObject *resultobj = 0;
26703 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26704 wxWindow *result = 0 ;
26705 void *argp1 = 0 ;
26706 int res1 = 0 ;
26707 PyObject *swig_obj[1] ;
26708
26709 if (!args) SWIG_fail;
26710 swig_obj[0] = args;
26711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26714 }
26715 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26716 {
26717 PyThreadState* __tstate = wxPyBeginAllowThreads();
26718 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = wxPyMake_wxObject(result, (bool)0);
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj = 0;
26733 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26734 wxWindow *arg2 = (wxWindow *) 0 ;
26735 void *argp1 = 0 ;
26736 int res1 = 0 ;
26737 void *argp2 = 0 ;
26738 int res2 = 0 ;
26739 PyObject * obj0 = 0 ;
26740 PyObject * obj1 = 0 ;
26741 char * kwnames[] = {
26742 (char *) "self",(char *) "win", NULL
26743 };
26744
26745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26747 if (!SWIG_IsOK(res1)) {
26748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26749 }
26750 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26752 if (!SWIG_IsOK(res2)) {
26753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26754 }
26755 arg2 = reinterpret_cast< wxWindow * >(argp2);
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 (arg1)->SetWindow(arg2);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_Py_Void();
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26770 PyObject *obj;
26771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26772 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26773 return SWIG_Py_Void();
26774 }
26775
26776 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26777 return SWIG_Python_InitShadowInstance(args);
26778 }
26779
26780 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26781 PyObject *resultobj = 0;
26782 wxWindow *arg1 = (wxWindow *) NULL ;
26783 wxChildFocusEvent *result = 0 ;
26784 void *argp1 = 0 ;
26785 int res1 = 0 ;
26786 PyObject * obj0 = 0 ;
26787 char * kwnames[] = {
26788 (char *) "win", NULL
26789 };
26790
26791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26792 if (obj0) {
26793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26794 if (!SWIG_IsOK(res1)) {
26795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26796 }
26797 arg1 = reinterpret_cast< wxWindow * >(argp1);
26798 }
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26813 PyObject *resultobj = 0;
26814 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26815 wxWindow *result = 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 PyObject *swig_obj[1] ;
26819
26820 if (!args) SWIG_fail;
26821 swig_obj[0] = args;
26822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26825 }
26826 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 {
26834 resultobj = wxPyMake_wxObject(result, (bool)0);
26835 }
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26843 PyObject *obj;
26844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26845 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26846 return SWIG_Py_Void();
26847 }
26848
26849 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26850 return SWIG_Python_InitShadowInstance(args);
26851 }
26852
26853 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = 0;
26855 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26856 bool arg2 = (bool) true ;
26857 int arg3 = (int) 0 ;
26858 wxActivateEvent *result = 0 ;
26859 int val1 ;
26860 int ecode1 = 0 ;
26861 bool val2 ;
26862 int ecode2 = 0 ;
26863 int val3 ;
26864 int ecode3 = 0 ;
26865 PyObject * obj0 = 0 ;
26866 PyObject * obj1 = 0 ;
26867 PyObject * obj2 = 0 ;
26868 char * kwnames[] = {
26869 (char *) "type",(char *) "active",(char *) "Id", NULL
26870 };
26871
26872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26873 if (obj0) {
26874 ecode1 = SWIG_AsVal_int(obj0, &val1);
26875 if (!SWIG_IsOK(ecode1)) {
26876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26877 }
26878 arg1 = static_cast< wxEventType >(val1);
26879 }
26880 if (obj1) {
26881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26882 if (!SWIG_IsOK(ecode2)) {
26883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26884 }
26885 arg2 = static_cast< bool >(val2);
26886 }
26887 if (obj2) {
26888 ecode3 = SWIG_AsVal_int(obj2, &val3);
26889 if (!SWIG_IsOK(ecode3)) {
26890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26891 }
26892 arg3 = static_cast< int >(val3);
26893 }
26894 {
26895 PyThreadState* __tstate = wxPyBeginAllowThreads();
26896 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26897 wxPyEndAllowThreads(__tstate);
26898 if (PyErr_Occurred()) SWIG_fail;
26899 }
26900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26901 return resultobj;
26902 fail:
26903 return NULL;
26904 }
26905
26906
26907 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26908 PyObject *resultobj = 0;
26909 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26910 bool result;
26911 void *argp1 = 0 ;
26912 int res1 = 0 ;
26913 PyObject *swig_obj[1] ;
26914
26915 if (!args) SWIG_fail;
26916 swig_obj[0] = args;
26917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26918 if (!SWIG_IsOK(res1)) {
26919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26920 }
26921 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26922 {
26923 PyThreadState* __tstate = wxPyBeginAllowThreads();
26924 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26925 wxPyEndAllowThreads(__tstate);
26926 if (PyErr_Occurred()) SWIG_fail;
26927 }
26928 {
26929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26930 }
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26938 PyObject *obj;
26939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26940 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26941 return SWIG_Py_Void();
26942 }
26943
26944 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26945 return SWIG_Python_InitShadowInstance(args);
26946 }
26947
26948 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj = 0;
26950 int arg1 = (int) 0 ;
26951 wxInitDialogEvent *result = 0 ;
26952 int val1 ;
26953 int ecode1 = 0 ;
26954 PyObject * obj0 = 0 ;
26955 char * kwnames[] = {
26956 (char *) "Id", NULL
26957 };
26958
26959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26960 if (obj0) {
26961 ecode1 = SWIG_AsVal_int(obj0, &val1);
26962 if (!SWIG_IsOK(ecode1)) {
26963 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26964 }
26965 arg1 = static_cast< int >(val1);
26966 }
26967 {
26968 PyThreadState* __tstate = wxPyBeginAllowThreads();
26969 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26981 PyObject *obj;
26982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26983 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26984 return SWIG_Py_Void();
26985 }
26986
26987 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26988 return SWIG_Python_InitShadowInstance(args);
26989 }
26990
26991 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26992 PyObject *resultobj = 0;
26993 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26994 int arg2 = (int) 0 ;
26995 wxMenu *arg3 = (wxMenu *) NULL ;
26996 wxMenuEvent *result = 0 ;
26997 int val1 ;
26998 int ecode1 = 0 ;
26999 int val2 ;
27000 int ecode2 = 0 ;
27001 void *argp3 = 0 ;
27002 int res3 = 0 ;
27003 PyObject * obj0 = 0 ;
27004 PyObject * obj1 = 0 ;
27005 PyObject * obj2 = 0 ;
27006 char * kwnames[] = {
27007 (char *) "type",(char *) "winid",(char *) "menu", NULL
27008 };
27009
27010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27011 if (obj0) {
27012 ecode1 = SWIG_AsVal_int(obj0, &val1);
27013 if (!SWIG_IsOK(ecode1)) {
27014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27015 }
27016 arg1 = static_cast< wxEventType >(val1);
27017 }
27018 if (obj1) {
27019 ecode2 = SWIG_AsVal_int(obj1, &val2);
27020 if (!SWIG_IsOK(ecode2)) {
27021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27022 }
27023 arg2 = static_cast< int >(val2);
27024 }
27025 if (obj2) {
27026 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27027 if (!SWIG_IsOK(res3)) {
27028 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27029 }
27030 arg3 = reinterpret_cast< wxMenu * >(argp3);
27031 }
27032 {
27033 PyThreadState* __tstate = wxPyBeginAllowThreads();
27034 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *resultobj = 0;
27047 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27048 int result;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 PyObject *swig_obj[1] ;
27052
27053 if (!args) SWIG_fail;
27054 swig_obj[0] = args;
27055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27058 }
27059 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 resultobj = SWIG_From_int(static_cast< int >(result));
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27074 PyObject *resultobj = 0;
27075 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27076 bool result;
27077 void *argp1 = 0 ;
27078 int res1 = 0 ;
27079 PyObject *swig_obj[1] ;
27080
27081 if (!args) SWIG_fail;
27082 swig_obj[0] = args;
27083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27084 if (!SWIG_IsOK(res1)) {
27085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27086 }
27087 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 {
27095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27096 }
27097 return resultobj;
27098 fail:
27099 return NULL;
27100 }
27101
27102
27103 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27104 PyObject *resultobj = 0;
27105 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27106 wxMenu *result = 0 ;
27107 void *argp1 = 0 ;
27108 int res1 = 0 ;
27109 PyObject *swig_obj[1] ;
27110
27111 if (!args) SWIG_fail;
27112 swig_obj[0] = args;
27113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27114 if (!SWIG_IsOK(res1)) {
27115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27116 }
27117 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 resultobj = wxPyMake_wxObject(result, (bool)0);
27126 }
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27134 PyObject *obj;
27135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27136 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27137 return SWIG_Py_Void();
27138 }
27139
27140 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27141 return SWIG_Python_InitShadowInstance(args);
27142 }
27143
27144 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj = 0;
27146 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27147 int arg2 = (int) 0 ;
27148 wxCloseEvent *result = 0 ;
27149 int val1 ;
27150 int ecode1 = 0 ;
27151 int val2 ;
27152 int ecode2 = 0 ;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 char * kwnames[] = {
27156 (char *) "type",(char *) "winid", NULL
27157 };
27158
27159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27160 if (obj0) {
27161 ecode1 = SWIG_AsVal_int(obj0, &val1);
27162 if (!SWIG_IsOK(ecode1)) {
27163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27164 }
27165 arg1 = static_cast< wxEventType >(val1);
27166 }
27167 if (obj1) {
27168 ecode2 = SWIG_AsVal_int(obj1, &val2);
27169 if (!SWIG_IsOK(ecode2)) {
27170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27171 }
27172 arg2 = static_cast< int >(val2);
27173 }
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27181 return resultobj;
27182 fail:
27183 return NULL;
27184 }
27185
27186
27187 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27188 PyObject *resultobj = 0;
27189 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27190 bool arg2 ;
27191 void *argp1 = 0 ;
27192 int res1 = 0 ;
27193 bool val2 ;
27194 int ecode2 = 0 ;
27195 PyObject * obj0 = 0 ;
27196 PyObject * obj1 = 0 ;
27197 char * kwnames[] = {
27198 (char *) "self",(char *) "logOff", NULL
27199 };
27200
27201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27203 if (!SWIG_IsOK(res1)) {
27204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27205 }
27206 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27208 if (!SWIG_IsOK(ecode2)) {
27209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27210 }
27211 arg2 = static_cast< bool >(val2);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 (arg1)->SetLoggingOff(arg2);
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 resultobj = SWIG_Py_Void();
27219 return resultobj;
27220 fail:
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27226 PyObject *resultobj = 0;
27227 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27228 bool result;
27229 void *argp1 = 0 ;
27230 int res1 = 0 ;
27231 PyObject *swig_obj[1] ;
27232
27233 if (!args) SWIG_fail;
27234 swig_obj[0] = args;
27235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27236 if (!SWIG_IsOK(res1)) {
27237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27238 }
27239 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 {
27247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27248 }
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27256 PyObject *resultobj = 0;
27257 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27258 bool arg2 = (bool) true ;
27259 void *argp1 = 0 ;
27260 int res1 = 0 ;
27261 bool val2 ;
27262 int ecode2 = 0 ;
27263 PyObject * obj0 = 0 ;
27264 PyObject * obj1 = 0 ;
27265 char * kwnames[] = {
27266 (char *) "self",(char *) "veto", NULL
27267 };
27268
27269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27271 if (!SWIG_IsOK(res1)) {
27272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27273 }
27274 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27275 if (obj1) {
27276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27277 if (!SWIG_IsOK(ecode2)) {
27278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27279 }
27280 arg2 = static_cast< bool >(val2);
27281 }
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 (arg1)->Veto(arg2);
27285 wxPyEndAllowThreads(__tstate);
27286 if (PyErr_Occurred()) SWIG_fail;
27287 }
27288 resultobj = SWIG_Py_Void();
27289 return resultobj;
27290 fail:
27291 return NULL;
27292 }
27293
27294
27295 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27296 PyObject *resultobj = 0;
27297 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27298 bool result;
27299 void *argp1 = 0 ;
27300 int res1 = 0 ;
27301 PyObject *swig_obj[1] ;
27302
27303 if (!args) SWIG_fail;
27304 swig_obj[0] = args;
27305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27306 if (!SWIG_IsOK(res1)) {
27307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27308 }
27309 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 {
27317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27318 }
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27326 PyObject *resultobj = 0;
27327 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27328 bool arg2 ;
27329 void *argp1 = 0 ;
27330 int res1 = 0 ;
27331 bool val2 ;
27332 int ecode2 = 0 ;
27333 PyObject * obj0 = 0 ;
27334 PyObject * obj1 = 0 ;
27335 char * kwnames[] = {
27336 (char *) "self",(char *) "canVeto", NULL
27337 };
27338
27339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27341 if (!SWIG_IsOK(res1)) {
27342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27343 }
27344 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27346 if (!SWIG_IsOK(ecode2)) {
27347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27348 }
27349 arg2 = static_cast< bool >(val2);
27350 {
27351 PyThreadState* __tstate = wxPyBeginAllowThreads();
27352 (arg1)->SetCanVeto(arg2);
27353 wxPyEndAllowThreads(__tstate);
27354 if (PyErr_Occurred()) SWIG_fail;
27355 }
27356 resultobj = SWIG_Py_Void();
27357 return resultobj;
27358 fail:
27359 return NULL;
27360 }
27361
27362
27363 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27364 PyObject *resultobj = 0;
27365 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27366 bool result;
27367 void *argp1 = 0 ;
27368 int res1 = 0 ;
27369 PyObject *swig_obj[1] ;
27370
27371 if (!args) SWIG_fail;
27372 swig_obj[0] = args;
27373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27374 if (!SWIG_IsOK(res1)) {
27375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27376 }
27377 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27378 {
27379 PyThreadState* __tstate = wxPyBeginAllowThreads();
27380 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27381 wxPyEndAllowThreads(__tstate);
27382 if (PyErr_Occurred()) SWIG_fail;
27383 }
27384 {
27385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27386 }
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27394 PyObject *obj;
27395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27396 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27397 return SWIG_Py_Void();
27398 }
27399
27400 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27401 return SWIG_Python_InitShadowInstance(args);
27402 }
27403
27404 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27405 PyObject *resultobj = 0;
27406 int arg1 = (int) 0 ;
27407 bool arg2 = (bool) false ;
27408 wxShowEvent *result = 0 ;
27409 int val1 ;
27410 int ecode1 = 0 ;
27411 bool val2 ;
27412 int ecode2 = 0 ;
27413 PyObject * obj0 = 0 ;
27414 PyObject * obj1 = 0 ;
27415 char * kwnames[] = {
27416 (char *) "winid",(char *) "show", NULL
27417 };
27418
27419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27420 if (obj0) {
27421 ecode1 = SWIG_AsVal_int(obj0, &val1);
27422 if (!SWIG_IsOK(ecode1)) {
27423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27424 }
27425 arg1 = static_cast< int >(val1);
27426 }
27427 if (obj1) {
27428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27429 if (!SWIG_IsOK(ecode2)) {
27430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27431 }
27432 arg2 = static_cast< bool >(val2);
27433 }
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27437 wxPyEndAllowThreads(__tstate);
27438 if (PyErr_Occurred()) SWIG_fail;
27439 }
27440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27441 return resultobj;
27442 fail:
27443 return NULL;
27444 }
27445
27446
27447 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27448 PyObject *resultobj = 0;
27449 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27450 bool arg2 ;
27451 void *argp1 = 0 ;
27452 int res1 = 0 ;
27453 bool val2 ;
27454 int ecode2 = 0 ;
27455 PyObject * obj0 = 0 ;
27456 PyObject * obj1 = 0 ;
27457 char * kwnames[] = {
27458 (char *) "self",(char *) "show", NULL
27459 };
27460
27461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27465 }
27466 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27467 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27468 if (!SWIG_IsOK(ecode2)) {
27469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27470 }
27471 arg2 = static_cast< bool >(val2);
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 (arg1)->SetShow(arg2);
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = SWIG_Py_Void();
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *resultobj = 0;
27487 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27488 bool result;
27489 void *argp1 = 0 ;
27490 int res1 = 0 ;
27491 PyObject *swig_obj[1] ;
27492
27493 if (!args) SWIG_fail;
27494 swig_obj[0] = args;
27495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27496 if (!SWIG_IsOK(res1)) {
27497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27498 }
27499 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 {
27507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27508 }
27509 return resultobj;
27510 fail:
27511 return NULL;
27512 }
27513
27514
27515 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27516 PyObject *obj;
27517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27518 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27519 return SWIG_Py_Void();
27520 }
27521
27522 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27523 return SWIG_Python_InitShadowInstance(args);
27524 }
27525
27526 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27527 PyObject *resultobj = 0;
27528 int arg1 = (int) 0 ;
27529 bool arg2 = (bool) true ;
27530 wxIconizeEvent *result = 0 ;
27531 int val1 ;
27532 int ecode1 = 0 ;
27533 bool val2 ;
27534 int ecode2 = 0 ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 char * kwnames[] = {
27538 (char *) "id",(char *) "iconized", NULL
27539 };
27540
27541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27542 if (obj0) {
27543 ecode1 = SWIG_AsVal_int(obj0, &val1);
27544 if (!SWIG_IsOK(ecode1)) {
27545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27546 }
27547 arg1 = static_cast< int >(val1);
27548 }
27549 if (obj1) {
27550 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27551 if (!SWIG_IsOK(ecode2)) {
27552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27553 }
27554 arg2 = static_cast< bool >(val2);
27555 }
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27570 PyObject *resultobj = 0;
27571 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27572 bool result;
27573 void *argp1 = 0 ;
27574 int res1 = 0 ;
27575 PyObject *swig_obj[1] ;
27576
27577 if (!args) SWIG_fail;
27578 swig_obj[0] = args;
27579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27580 if (!SWIG_IsOK(res1)) {
27581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27582 }
27583 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27584 {
27585 PyThreadState* __tstate = wxPyBeginAllowThreads();
27586 result = (bool)(arg1)->Iconized();
27587 wxPyEndAllowThreads(__tstate);
27588 if (PyErr_Occurred()) SWIG_fail;
27589 }
27590 {
27591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27592 }
27593 return resultobj;
27594 fail:
27595 return NULL;
27596 }
27597
27598
27599 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27600 PyObject *obj;
27601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27602 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27603 return SWIG_Py_Void();
27604 }
27605
27606 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27607 return SWIG_Python_InitShadowInstance(args);
27608 }
27609
27610 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27611 PyObject *resultobj = 0;
27612 int arg1 = (int) 0 ;
27613 wxMaximizeEvent *result = 0 ;
27614 int val1 ;
27615 int ecode1 = 0 ;
27616 PyObject * obj0 = 0 ;
27617 char * kwnames[] = {
27618 (char *) "id", NULL
27619 };
27620
27621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27622 if (obj0) {
27623 ecode1 = SWIG_AsVal_int(obj0, &val1);
27624 if (!SWIG_IsOK(ecode1)) {
27625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27626 }
27627 arg1 = static_cast< int >(val1);
27628 }
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27636 return resultobj;
27637 fail:
27638 return NULL;
27639 }
27640
27641
27642 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27643 PyObject *obj;
27644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27645 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27646 return SWIG_Py_Void();
27647 }
27648
27649 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27650 return SWIG_Python_InitShadowInstance(args);
27651 }
27652
27653 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27654 PyObject *resultobj = 0;
27655 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27656 wxPoint result;
27657 void *argp1 = 0 ;
27658 int res1 = 0 ;
27659 PyObject *swig_obj[1] ;
27660
27661 if (!args) SWIG_fail;
27662 swig_obj[0] = args;
27663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27664 if (!SWIG_IsOK(res1)) {
27665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27666 }
27667 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 result = (arg1)->GetPosition();
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27682 PyObject *resultobj = 0;
27683 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27684 int result;
27685 void *argp1 = 0 ;
27686 int res1 = 0 ;
27687 PyObject *swig_obj[1] ;
27688
27689 if (!args) SWIG_fail;
27690 swig_obj[0] = args;
27691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27692 if (!SWIG_IsOK(res1)) {
27693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27694 }
27695 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (int)(arg1)->GetNumberOfFiles();
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 resultobj = SWIG_From_int(static_cast< int >(result));
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27710 PyObject *resultobj = 0;
27711 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27712 PyObject *result = 0 ;
27713 void *argp1 = 0 ;
27714 int res1 = 0 ;
27715 PyObject *swig_obj[1] ;
27716
27717 if (!args) SWIG_fail;
27718 swig_obj[0] = args;
27719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27720 if (!SWIG_IsOK(res1)) {
27721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27722 }
27723 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27724 {
27725 PyThreadState* __tstate = wxPyBeginAllowThreads();
27726 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 resultobj = result;
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27738 PyObject *obj;
27739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27740 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27741 return SWIG_Py_Void();
27742 }
27743
27744 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27745 PyObject *resultobj = 0;
27746 int arg1 = (int) 0 ;
27747 wxUpdateUIEvent *result = 0 ;
27748 int val1 ;
27749 int ecode1 = 0 ;
27750 PyObject * obj0 = 0 ;
27751 char * kwnames[] = {
27752 (char *) "commandId", NULL
27753 };
27754
27755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27756 if (obj0) {
27757 ecode1 = SWIG_AsVal_int(obj0, &val1);
27758 if (!SWIG_IsOK(ecode1)) {
27759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27760 }
27761 arg1 = static_cast< int >(val1);
27762 }
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27777 PyObject *resultobj = 0;
27778 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27779 bool result;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 PyObject *swig_obj[1] ;
27783
27784 if (!args) SWIG_fail;
27785 swig_obj[0] = args;
27786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27787 if (!SWIG_IsOK(res1)) {
27788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27789 }
27790 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27791 {
27792 PyThreadState* __tstate = wxPyBeginAllowThreads();
27793 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27794 wxPyEndAllowThreads(__tstate);
27795 if (PyErr_Occurred()) SWIG_fail;
27796 }
27797 {
27798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27799 }
27800 return resultobj;
27801 fail:
27802 return NULL;
27803 }
27804
27805
27806 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27807 PyObject *resultobj = 0;
27808 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27809 bool result;
27810 void *argp1 = 0 ;
27811 int res1 = 0 ;
27812 PyObject *swig_obj[1] ;
27813
27814 if (!args) SWIG_fail;
27815 swig_obj[0] = args;
27816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27817 if (!SWIG_IsOK(res1)) {
27818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27819 }
27820 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27821 {
27822 PyThreadState* __tstate = wxPyBeginAllowThreads();
27823 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 {
27828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27829 }
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27837 PyObject *resultobj = 0;
27838 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27839 bool result;
27840 void *argp1 = 0 ;
27841 int res1 = 0 ;
27842 PyObject *swig_obj[1] ;
27843
27844 if (!args) SWIG_fail;
27845 swig_obj[0] = args;
27846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27847 if (!SWIG_IsOK(res1)) {
27848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27849 }
27850 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27854 wxPyEndAllowThreads(__tstate);
27855 if (PyErr_Occurred()) SWIG_fail;
27856 }
27857 {
27858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27859 }
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27869 wxString result;
27870 void *argp1 = 0 ;
27871 int res1 = 0 ;
27872 PyObject *swig_obj[1] ;
27873
27874 if (!args) SWIG_fail;
27875 swig_obj[0] = args;
27876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27877 if (!SWIG_IsOK(res1)) {
27878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27879 }
27880 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 {
27888 #if wxUSE_UNICODE
27889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27890 #else
27891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27892 #endif
27893 }
27894 return resultobj;
27895 fail:
27896 return NULL;
27897 }
27898
27899
27900 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27901 PyObject *resultobj = 0;
27902 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27903 bool result;
27904 void *argp1 = 0 ;
27905 int res1 = 0 ;
27906 PyObject *swig_obj[1] ;
27907
27908 if (!args) SWIG_fail;
27909 swig_obj[0] = args;
27910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27911 if (!SWIG_IsOK(res1)) {
27912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27913 }
27914 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27923 }
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27931 PyObject *resultobj = 0;
27932 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27933 bool result;
27934 void *argp1 = 0 ;
27935 int res1 = 0 ;
27936 PyObject *swig_obj[1] ;
27937
27938 if (!args) SWIG_fail;
27939 swig_obj[0] = args;
27940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27941 if (!SWIG_IsOK(res1)) {
27942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27943 }
27944 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 {
27952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27953 }
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27961 PyObject *resultobj = 0;
27962 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27963 bool result;
27964 void *argp1 = 0 ;
27965 int res1 = 0 ;
27966 PyObject *swig_obj[1] ;
27967
27968 if (!args) SWIG_fail;
27969 swig_obj[0] = args;
27970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27971 if (!SWIG_IsOK(res1)) {
27972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27973 }
27974 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 {
27982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27983 }
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27991 PyObject *resultobj = 0;
27992 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27993 bool result;
27994 void *argp1 = 0 ;
27995 int res1 = 0 ;
27996 PyObject *swig_obj[1] ;
27997
27998 if (!args) SWIG_fail;
27999 swig_obj[0] = args;
28000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28003 }
28004 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 {
28012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28013 }
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28021 PyObject *resultobj = 0;
28022 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28023 bool arg2 ;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 bool val2 ;
28027 int ecode2 = 0 ;
28028 PyObject * obj0 = 0 ;
28029 PyObject * obj1 = 0 ;
28030 char * kwnames[] = {
28031 (char *) "self",(char *) "check", NULL
28032 };
28033
28034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28036 if (!SWIG_IsOK(res1)) {
28037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28038 }
28039 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28040 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28041 if (!SWIG_IsOK(ecode2)) {
28042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28043 }
28044 arg2 = static_cast< bool >(val2);
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 (arg1)->Check(arg2);
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 resultobj = SWIG_Py_Void();
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = 0;
28060 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28061 bool arg2 ;
28062 void *argp1 = 0 ;
28063 int res1 = 0 ;
28064 bool val2 ;
28065 int ecode2 = 0 ;
28066 PyObject * obj0 = 0 ;
28067 PyObject * obj1 = 0 ;
28068 char * kwnames[] = {
28069 (char *) "self",(char *) "enable", NULL
28070 };
28071
28072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28074 if (!SWIG_IsOK(res1)) {
28075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28076 }
28077 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28078 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28079 if (!SWIG_IsOK(ecode2)) {
28080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28081 }
28082 arg2 = static_cast< bool >(val2);
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 (arg1)->Enable(arg2);
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 resultobj = SWIG_Py_Void();
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28097 PyObject *resultobj = 0;
28098 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28099 bool arg2 ;
28100 void *argp1 = 0 ;
28101 int res1 = 0 ;
28102 bool val2 ;
28103 int ecode2 = 0 ;
28104 PyObject * obj0 = 0 ;
28105 PyObject * obj1 = 0 ;
28106 char * kwnames[] = {
28107 (char *) "self",(char *) "show", NULL
28108 };
28109
28110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28112 if (!SWIG_IsOK(res1)) {
28113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28114 }
28115 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28117 if (!SWIG_IsOK(ecode2)) {
28118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28119 }
28120 arg2 = static_cast< bool >(val2);
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 (arg1)->Show(arg2);
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 resultobj = SWIG_Py_Void();
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj = 0;
28136 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28137 wxString *arg2 = 0 ;
28138 void *argp1 = 0 ;
28139 int res1 = 0 ;
28140 bool temp2 = false ;
28141 PyObject * obj0 = 0 ;
28142 PyObject * obj1 = 0 ;
28143 char * kwnames[] = {
28144 (char *) "self",(char *) "text", NULL
28145 };
28146
28147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28149 if (!SWIG_IsOK(res1)) {
28150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28151 }
28152 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28153 {
28154 arg2 = wxString_in_helper(obj1);
28155 if (arg2 == NULL) SWIG_fail;
28156 temp2 = true;
28157 }
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 (arg1)->SetText((wxString const &)*arg2);
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 resultobj = SWIG_Py_Void();
28165 {
28166 if (temp2)
28167 delete arg2;
28168 }
28169 return resultobj;
28170 fail:
28171 {
28172 if (temp2)
28173 delete arg2;
28174 }
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = 0;
28181 long arg1 ;
28182 long val1 ;
28183 int ecode1 = 0 ;
28184 PyObject * obj0 = 0 ;
28185 char * kwnames[] = {
28186 (char *) "updateInterval", NULL
28187 };
28188
28189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28190 ecode1 = SWIG_AsVal_long(obj0, &val1);
28191 if (!SWIG_IsOK(ecode1)) {
28192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28193 }
28194 arg1 = static_cast< long >(val1);
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 wxUpdateUIEvent::SetUpdateInterval(arg1);
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_Py_Void();
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28209 PyObject *resultobj = 0;
28210 long result;
28211
28212 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 resultobj = SWIG_From_long(static_cast< long >(result));
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj = 0;
28228 wxWindow *arg1 = (wxWindow *) 0 ;
28229 bool result;
28230 void *argp1 = 0 ;
28231 int res1 = 0 ;
28232 PyObject * obj0 = 0 ;
28233 char * kwnames[] = {
28234 (char *) "win", NULL
28235 };
28236
28237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28239 if (!SWIG_IsOK(res1)) {
28240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28241 }
28242 arg1 = reinterpret_cast< wxWindow * >(argp1);
28243 {
28244 PyThreadState* __tstate = wxPyBeginAllowThreads();
28245 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 {
28250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28251 }
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28259 PyObject *resultobj = 0;
28260
28261 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 wxUpdateUIEvent::ResetUpdateTime();
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 resultobj = SWIG_Py_Void();
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj = 0;
28277 wxUpdateUIMode arg1 ;
28278 int val1 ;
28279 int ecode1 = 0 ;
28280 PyObject * obj0 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "mode", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28286 ecode1 = SWIG_AsVal_int(obj0, &val1);
28287 if (!SWIG_IsOK(ecode1)) {
28288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28289 }
28290 arg1 = static_cast< wxUpdateUIMode >(val1);
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 wxUpdateUIEvent::SetMode(arg1);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = SWIG_Py_Void();
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 wxUpdateUIMode result;
28307
28308 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 resultobj = SWIG_From_int(static_cast< int >(result));
28316 return resultobj;
28317 fail:
28318 return NULL;
28319 }
28320
28321
28322 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28323 PyObject *obj;
28324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28325 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28326 return SWIG_Py_Void();
28327 }
28328
28329 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 return SWIG_Python_InitShadowInstance(args);
28331 }
28332
28333 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28334 PyObject *resultobj = 0;
28335 wxSysColourChangedEvent *result = 0 ;
28336
28337 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28341 wxPyEndAllowThreads(__tstate);
28342 if (PyErr_Occurred()) SWIG_fail;
28343 }
28344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28345 return resultobj;
28346 fail:
28347 return NULL;
28348 }
28349
28350
28351 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28352 PyObject *obj;
28353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28354 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28355 return SWIG_Py_Void();
28356 }
28357
28358 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 return SWIG_Python_InitShadowInstance(args);
28360 }
28361
28362 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28363 PyObject *resultobj = 0;
28364 int arg1 = (int) 0 ;
28365 wxWindow *arg2 = (wxWindow *) NULL ;
28366 wxMouseCaptureChangedEvent *result = 0 ;
28367 int val1 ;
28368 int ecode1 = 0 ;
28369 void *argp2 = 0 ;
28370 int res2 = 0 ;
28371 PyObject * obj0 = 0 ;
28372 PyObject * obj1 = 0 ;
28373 char * kwnames[] = {
28374 (char *) "winid",(char *) "gainedCapture", NULL
28375 };
28376
28377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28378 if (obj0) {
28379 ecode1 = SWIG_AsVal_int(obj0, &val1);
28380 if (!SWIG_IsOK(ecode1)) {
28381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28382 }
28383 arg1 = static_cast< int >(val1);
28384 }
28385 if (obj1) {
28386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28387 if (!SWIG_IsOK(res2)) {
28388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28389 }
28390 arg2 = reinterpret_cast< wxWindow * >(argp2);
28391 }
28392 {
28393 PyThreadState* __tstate = wxPyBeginAllowThreads();
28394 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28395 wxPyEndAllowThreads(__tstate);
28396 if (PyErr_Occurred()) SWIG_fail;
28397 }
28398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28406 PyObject *resultobj = 0;
28407 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28408 wxWindow *result = 0 ;
28409 void *argp1 = 0 ;
28410 int res1 = 0 ;
28411 PyObject *swig_obj[1] ;
28412
28413 if (!args) SWIG_fail;
28414 swig_obj[0] = args;
28415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28416 if (!SWIG_IsOK(res1)) {
28417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28418 }
28419 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28420 {
28421 PyThreadState* __tstate = wxPyBeginAllowThreads();
28422 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28423 wxPyEndAllowThreads(__tstate);
28424 if (PyErr_Occurred()) SWIG_fail;
28425 }
28426 {
28427 resultobj = wxPyMake_wxObject(result, (bool)0);
28428 }
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 PyObject *obj;
28437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28438 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28439 return SWIG_Py_Void();
28440 }
28441
28442 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28443 return SWIG_Python_InitShadowInstance(args);
28444 }
28445
28446 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj = 0;
28448 int arg1 = (int) 0 ;
28449 wxMouseCaptureLostEvent *result = 0 ;
28450 int val1 ;
28451 int ecode1 = 0 ;
28452 PyObject * obj0 = 0 ;
28453 char * kwnames[] = {
28454 (char *) "winid", NULL
28455 };
28456
28457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28458 if (obj0) {
28459 ecode1 = SWIG_AsVal_int(obj0, &val1);
28460 if (!SWIG_IsOK(ecode1)) {
28461 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28462 }
28463 arg1 = static_cast< int >(val1);
28464 }
28465 {
28466 PyThreadState* __tstate = wxPyBeginAllowThreads();
28467 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28472 return resultobj;
28473 fail:
28474 return NULL;
28475 }
28476
28477
28478 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28479 PyObject *obj;
28480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28481 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28482 return SWIG_Py_Void();
28483 }
28484
28485 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28486 return SWIG_Python_InitShadowInstance(args);
28487 }
28488
28489 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28490 PyObject *resultobj = 0;
28491 wxDisplayChangedEvent *result = 0 ;
28492
28493 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28508 PyObject *obj;
28509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28510 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28511 return SWIG_Py_Void();
28512 }
28513
28514 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28515 return SWIG_Python_InitShadowInstance(args);
28516 }
28517
28518 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28519 PyObject *resultobj = 0;
28520 int arg1 = (int) 0 ;
28521 wxPaletteChangedEvent *result = 0 ;
28522 int val1 ;
28523 int ecode1 = 0 ;
28524 PyObject * obj0 = 0 ;
28525 char * kwnames[] = {
28526 (char *) "id", NULL
28527 };
28528
28529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28530 if (obj0) {
28531 ecode1 = SWIG_AsVal_int(obj0, &val1);
28532 if (!SWIG_IsOK(ecode1)) {
28533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28534 }
28535 arg1 = static_cast< int >(val1);
28536 }
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj = 0;
28552 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28553 wxWindow *arg2 = (wxWindow *) 0 ;
28554 void *argp1 = 0 ;
28555 int res1 = 0 ;
28556 void *argp2 = 0 ;
28557 int res2 = 0 ;
28558 PyObject * obj0 = 0 ;
28559 PyObject * obj1 = 0 ;
28560 char * kwnames[] = {
28561 (char *) "self",(char *) "win", NULL
28562 };
28563
28564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28566 if (!SWIG_IsOK(res1)) {
28567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28568 }
28569 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28571 if (!SWIG_IsOK(res2)) {
28572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28573 }
28574 arg2 = reinterpret_cast< wxWindow * >(argp2);
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 (arg1)->SetChangedWindow(arg2);
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_Py_Void();
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28589 PyObject *resultobj = 0;
28590 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28591 wxWindow *result = 0 ;
28592 void *argp1 = 0 ;
28593 int res1 = 0 ;
28594 PyObject *swig_obj[1] ;
28595
28596 if (!args) SWIG_fail;
28597 swig_obj[0] = args;
28598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28599 if (!SWIG_IsOK(res1)) {
28600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28601 }
28602 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (wxWindow *)(arg1)->GetChangedWindow();
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = wxPyMake_wxObject(result, (bool)0);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 PyObject *obj;
28620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28621 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28622 return SWIG_Py_Void();
28623 }
28624
28625 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28626 return SWIG_Python_InitShadowInstance(args);
28627 }
28628
28629 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28630 PyObject *resultobj = 0;
28631 int arg1 = (int) 0 ;
28632 wxQueryNewPaletteEvent *result = 0 ;
28633 int val1 ;
28634 int ecode1 = 0 ;
28635 PyObject * obj0 = 0 ;
28636 char * kwnames[] = {
28637 (char *) "winid", NULL
28638 };
28639
28640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28641 if (obj0) {
28642 ecode1 = SWIG_AsVal_int(obj0, &val1);
28643 if (!SWIG_IsOK(ecode1)) {
28644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28645 }
28646 arg1 = static_cast< int >(val1);
28647 }
28648 {
28649 PyThreadState* __tstate = wxPyBeginAllowThreads();
28650 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28651 wxPyEndAllowThreads(__tstate);
28652 if (PyErr_Occurred()) SWIG_fail;
28653 }
28654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28655 return resultobj;
28656 fail:
28657 return NULL;
28658 }
28659
28660
28661 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = 0;
28663 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28664 bool arg2 ;
28665 void *argp1 = 0 ;
28666 int res1 = 0 ;
28667 bool val2 ;
28668 int ecode2 = 0 ;
28669 PyObject * obj0 = 0 ;
28670 PyObject * obj1 = 0 ;
28671 char * kwnames[] = {
28672 (char *) "self",(char *) "realized", NULL
28673 };
28674
28675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28677 if (!SWIG_IsOK(res1)) {
28678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28679 }
28680 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28682 if (!SWIG_IsOK(ecode2)) {
28683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28684 }
28685 arg2 = static_cast< bool >(val2);
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 (arg1)->SetPaletteRealized(arg2);
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 resultobj = SWIG_Py_Void();
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28702 bool result;
28703 void *argp1 = 0 ;
28704 int res1 = 0 ;
28705 PyObject *swig_obj[1] ;
28706
28707 if (!args) SWIG_fail;
28708 swig_obj[0] = args;
28709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28710 if (!SWIG_IsOK(res1)) {
28711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28712 }
28713 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 {
28721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28722 }
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28730 PyObject *obj;
28731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28732 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28733 return SWIG_Py_Void();
28734 }
28735
28736 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 return SWIG_Python_InitShadowInstance(args);
28738 }
28739
28740 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 wxNavigationKeyEvent *result = 0 ;
28743
28744 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28759 PyObject *resultobj = 0;
28760 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28761 bool result;
28762 void *argp1 = 0 ;
28763 int res1 = 0 ;
28764 PyObject *swig_obj[1] ;
28765
28766 if (!args) SWIG_fail;
28767 swig_obj[0] = args;
28768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28769 if (!SWIG_IsOK(res1)) {
28770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28771 }
28772 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28776 wxPyEndAllowThreads(__tstate);
28777 if (PyErr_Occurred()) SWIG_fail;
28778 }
28779 {
28780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28781 }
28782 return resultobj;
28783 fail:
28784 return NULL;
28785 }
28786
28787
28788 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28789 PyObject *resultobj = 0;
28790 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28791 bool arg2 ;
28792 void *argp1 = 0 ;
28793 int res1 = 0 ;
28794 bool val2 ;
28795 int ecode2 = 0 ;
28796 PyObject * obj0 = 0 ;
28797 PyObject * obj1 = 0 ;
28798 char * kwnames[] = {
28799 (char *) "self",(char *) "forward", NULL
28800 };
28801
28802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28804 if (!SWIG_IsOK(res1)) {
28805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28806 }
28807 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28809 if (!SWIG_IsOK(ecode2)) {
28810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28811 }
28812 arg2 = static_cast< bool >(val2);
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 (arg1)->SetDirection(arg2);
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 resultobj = SWIG_Py_Void();
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28827 PyObject *resultobj = 0;
28828 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28829 bool result;
28830 void *argp1 = 0 ;
28831 int res1 = 0 ;
28832 PyObject *swig_obj[1] ;
28833
28834 if (!args) SWIG_fail;
28835 swig_obj[0] = args;
28836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28837 if (!SWIG_IsOK(res1)) {
28838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28839 }
28840 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28841 {
28842 PyThreadState* __tstate = wxPyBeginAllowThreads();
28843 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 {
28848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28849 }
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj = 0;
28858 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28859 bool arg2 ;
28860 void *argp1 = 0 ;
28861 int res1 = 0 ;
28862 bool val2 ;
28863 int ecode2 = 0 ;
28864 PyObject * obj0 = 0 ;
28865 PyObject * obj1 = 0 ;
28866 char * kwnames[] = {
28867 (char *) "self",(char *) "ischange", NULL
28868 };
28869
28870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28874 }
28875 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28877 if (!SWIG_IsOK(ecode2)) {
28878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28879 }
28880 arg2 = static_cast< bool >(val2);
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 (arg1)->SetWindowChange(arg2);
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_Py_Void();
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28895 PyObject *resultobj = 0;
28896 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28897 bool result;
28898 void *argp1 = 0 ;
28899 int res1 = 0 ;
28900 PyObject *swig_obj[1] ;
28901
28902 if (!args) SWIG_fail;
28903 swig_obj[0] = args;
28904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28905 if (!SWIG_IsOK(res1)) {
28906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28907 }
28908 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 {
28916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28917 }
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj = 0;
28926 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28927 bool arg2 ;
28928 void *argp1 = 0 ;
28929 int res1 = 0 ;
28930 bool val2 ;
28931 int ecode2 = 0 ;
28932 PyObject * obj0 = 0 ;
28933 PyObject * obj1 = 0 ;
28934 char * kwnames[] = {
28935 (char *) "self",(char *) "bIs", NULL
28936 };
28937
28938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28940 if (!SWIG_IsOK(res1)) {
28941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28942 }
28943 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28945 if (!SWIG_IsOK(ecode2)) {
28946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28947 }
28948 arg2 = static_cast< bool >(val2);
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 (arg1)->SetFromTab(arg2);
28952 wxPyEndAllowThreads(__tstate);
28953 if (PyErr_Occurred()) SWIG_fail;
28954 }
28955 resultobj = SWIG_Py_Void();
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28963 PyObject *resultobj = 0;
28964 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28965 long arg2 ;
28966 void *argp1 = 0 ;
28967 int res1 = 0 ;
28968 long val2 ;
28969 int ecode2 = 0 ;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 char * kwnames[] = {
28973 (char *) "self",(char *) "flags", NULL
28974 };
28975
28976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28978 if (!SWIG_IsOK(res1)) {
28979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28980 }
28981 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28982 ecode2 = SWIG_AsVal_long(obj1, &val2);
28983 if (!SWIG_IsOK(ecode2)) {
28984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28985 }
28986 arg2 = static_cast< long >(val2);
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 (arg1)->SetFlags(arg2);
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 resultobj = SWIG_Py_Void();
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29001 PyObject *resultobj = 0;
29002 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29003 wxWindow *result = 0 ;
29004 void *argp1 = 0 ;
29005 int res1 = 0 ;
29006 PyObject *swig_obj[1] ;
29007
29008 if (!args) SWIG_fail;
29009 swig_obj[0] = args;
29010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29011 if (!SWIG_IsOK(res1)) {
29012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29013 }
29014 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29015 {
29016 PyThreadState* __tstate = wxPyBeginAllowThreads();
29017 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 {
29022 resultobj = wxPyMake_wxObject(result, (bool)0);
29023 }
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj = 0;
29032 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29033 wxWindow *arg2 = (wxWindow *) 0 ;
29034 void *argp1 = 0 ;
29035 int res1 = 0 ;
29036 void *argp2 = 0 ;
29037 int res2 = 0 ;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 char * kwnames[] = {
29041 (char *) "self",(char *) "win", NULL
29042 };
29043
29044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29046 if (!SWIG_IsOK(res1)) {
29047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29048 }
29049 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29051 if (!SWIG_IsOK(res2)) {
29052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29053 }
29054 arg2 = reinterpret_cast< wxWindow * >(argp2);
29055 {
29056 PyThreadState* __tstate = wxPyBeginAllowThreads();
29057 (arg1)->SetCurrentFocus(arg2);
29058 wxPyEndAllowThreads(__tstate);
29059 if (PyErr_Occurred()) SWIG_fail;
29060 }
29061 resultobj = SWIG_Py_Void();
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29069 PyObject *obj;
29070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29071 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29072 return SWIG_Py_Void();
29073 }
29074
29075 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 return SWIG_Python_InitShadowInstance(args);
29077 }
29078
29079 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 wxWindow *arg1 = (wxWindow *) NULL ;
29082 wxWindowCreateEvent *result = 0 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 PyObject * obj0 = 0 ;
29086 char * kwnames[] = {
29087 (char *) "win", NULL
29088 };
29089
29090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29091 if (obj0) {
29092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29093 if (!SWIG_IsOK(res1)) {
29094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29095 }
29096 arg1 = reinterpret_cast< wxWindow * >(argp1);
29097 }
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29112 PyObject *resultobj = 0;
29113 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29114 wxWindow *result = 0 ;
29115 void *argp1 = 0 ;
29116 int res1 = 0 ;
29117 PyObject *swig_obj[1] ;
29118
29119 if (!args) SWIG_fail;
29120 swig_obj[0] = args;
29121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29122 if (!SWIG_IsOK(res1)) {
29123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29124 }
29125 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29129 wxPyEndAllowThreads(__tstate);
29130 if (PyErr_Occurred()) SWIG_fail;
29131 }
29132 {
29133 resultobj = wxPyMake_wxObject(result, (bool)0);
29134 }
29135 return resultobj;
29136 fail:
29137 return NULL;
29138 }
29139
29140
29141 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29142 PyObject *obj;
29143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29144 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29145 return SWIG_Py_Void();
29146 }
29147
29148 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29149 return SWIG_Python_InitShadowInstance(args);
29150 }
29151
29152 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj = 0;
29154 wxWindow *arg1 = (wxWindow *) NULL ;
29155 wxWindowDestroyEvent *result = 0 ;
29156 void *argp1 = 0 ;
29157 int res1 = 0 ;
29158 PyObject * obj0 = 0 ;
29159 char * kwnames[] = {
29160 (char *) "win", NULL
29161 };
29162
29163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29164 if (obj0) {
29165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29166 if (!SWIG_IsOK(res1)) {
29167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29168 }
29169 arg1 = reinterpret_cast< wxWindow * >(argp1);
29170 }
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29187 wxWindow *result = 0 ;
29188 void *argp1 = 0 ;
29189 int res1 = 0 ;
29190 PyObject *swig_obj[1] ;
29191
29192 if (!args) SWIG_fail;
29193 swig_obj[0] = args;
29194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29195 if (!SWIG_IsOK(res1)) {
29196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29197 }
29198 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 {
29206 resultobj = wxPyMake_wxObject(result, (bool)0);
29207 }
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29215 PyObject *obj;
29216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29217 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29218 return SWIG_Py_Void();
29219 }
29220
29221 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 return SWIG_Python_InitShadowInstance(args);
29223 }
29224
29225 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29226 PyObject *resultobj = 0;
29227 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29228 int arg2 = (int) 0 ;
29229 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29230 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29231 wxContextMenuEvent *result = 0 ;
29232 int val1 ;
29233 int ecode1 = 0 ;
29234 int val2 ;
29235 int ecode2 = 0 ;
29236 wxPoint temp3 ;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 PyObject * obj2 = 0 ;
29240 char * kwnames[] = {
29241 (char *) "type",(char *) "winid",(char *) "pt", NULL
29242 };
29243
29244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29245 if (obj0) {
29246 ecode1 = SWIG_AsVal_int(obj0, &val1);
29247 if (!SWIG_IsOK(ecode1)) {
29248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29249 }
29250 arg1 = static_cast< wxEventType >(val1);
29251 }
29252 if (obj1) {
29253 ecode2 = SWIG_AsVal_int(obj1, &val2);
29254 if (!SWIG_IsOK(ecode2)) {
29255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29256 }
29257 arg2 = static_cast< int >(val2);
29258 }
29259 if (obj2) {
29260 {
29261 arg3 = &temp3;
29262 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29263 }
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29281 wxPoint *result = 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 PyObject *swig_obj[1] ;
29285
29286 if (!args) SWIG_fail;
29287 swig_obj[0] = args;
29288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29291 }
29292 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29293 {
29294 PyThreadState* __tstate = wxPyBeginAllowThreads();
29295 {
29296 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29297 result = (wxPoint *) &_result_ref;
29298 }
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29310 PyObject *resultobj = 0;
29311 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29312 wxPoint *arg2 = 0 ;
29313 void *argp1 = 0 ;
29314 int res1 = 0 ;
29315 wxPoint temp2 ;
29316 PyObject * obj0 = 0 ;
29317 PyObject * obj1 = 0 ;
29318 char * kwnames[] = {
29319 (char *) "self",(char *) "pos", NULL
29320 };
29321
29322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29324 if (!SWIG_IsOK(res1)) {
29325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29326 }
29327 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29328 {
29329 arg2 = &temp2;
29330 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29331 }
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 (arg1)->SetPosition((wxPoint const &)*arg2);
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 resultobj = SWIG_Py_Void();
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29346 PyObject *obj;
29347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29348 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29349 return SWIG_Py_Void();
29350 }
29351
29352 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29353 return SWIG_Python_InitShadowInstance(args);
29354 }
29355
29356 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29357 PyObject *resultobj = 0;
29358 wxIdleEvent *result = 0 ;
29359
29360 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 result = (wxIdleEvent *)new wxIdleEvent();
29364 wxPyEndAllowThreads(__tstate);
29365 if (PyErr_Occurred()) SWIG_fail;
29366 }
29367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29368 return resultobj;
29369 fail:
29370 return NULL;
29371 }
29372
29373
29374 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29375 PyObject *resultobj = 0;
29376 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29377 bool arg2 = (bool) true ;
29378 void *argp1 = 0 ;
29379 int res1 = 0 ;
29380 bool val2 ;
29381 int ecode2 = 0 ;
29382 PyObject * obj0 = 0 ;
29383 PyObject * obj1 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "self",(char *) "needMore", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29390 if (!SWIG_IsOK(res1)) {
29391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29392 }
29393 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29394 if (obj1) {
29395 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29396 if (!SWIG_IsOK(ecode2)) {
29397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29398 }
29399 arg2 = static_cast< bool >(val2);
29400 }
29401 {
29402 PyThreadState* __tstate = wxPyBeginAllowThreads();
29403 (arg1)->RequestMore(arg2);
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 resultobj = SWIG_Py_Void();
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29415 PyObject *resultobj = 0;
29416 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29417 bool result;
29418 void *argp1 = 0 ;
29419 int res1 = 0 ;
29420 PyObject *swig_obj[1] ;
29421
29422 if (!args) SWIG_fail;
29423 swig_obj[0] = args;
29424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29427 }
29428 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 {
29436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29437 }
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29445 PyObject *resultobj = 0;
29446 wxIdleMode arg1 ;
29447 int val1 ;
29448 int ecode1 = 0 ;
29449 PyObject * obj0 = 0 ;
29450 char * kwnames[] = {
29451 (char *) "mode", NULL
29452 };
29453
29454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29455 ecode1 = SWIG_AsVal_int(obj0, &val1);
29456 if (!SWIG_IsOK(ecode1)) {
29457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29458 }
29459 arg1 = static_cast< wxIdleMode >(val1);
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 wxIdleEvent::SetMode(arg1);
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 resultobj = SWIG_Py_Void();
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 wxIdleMode result;
29476
29477 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29478 {
29479 PyThreadState* __tstate = wxPyBeginAllowThreads();
29480 result = (wxIdleMode)wxIdleEvent::GetMode();
29481 wxPyEndAllowThreads(__tstate);
29482 if (PyErr_Occurred()) SWIG_fail;
29483 }
29484 resultobj = SWIG_From_int(static_cast< int >(result));
29485 return resultobj;
29486 fail:
29487 return NULL;
29488 }
29489
29490
29491 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29492 PyObject *resultobj = 0;
29493 wxWindow *arg1 = (wxWindow *) 0 ;
29494 bool result;
29495 void *argp1 = 0 ;
29496 int res1 = 0 ;
29497 PyObject * obj0 = 0 ;
29498 char * kwnames[] = {
29499 (char *) "win", NULL
29500 };
29501
29502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29504 if (!SWIG_IsOK(res1)) {
29505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29506 }
29507 arg1 = reinterpret_cast< wxWindow * >(argp1);
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 result = (bool)wxIdleEvent::CanSend(arg1);
29511 wxPyEndAllowThreads(__tstate);
29512 if (PyErr_Occurred()) SWIG_fail;
29513 }
29514 {
29515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29516 }
29517 return resultobj;
29518 fail:
29519 return NULL;
29520 }
29521
29522
29523 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29524 PyObject *obj;
29525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29526 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29527 return SWIG_Py_Void();
29528 }
29529
29530 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29531 return SWIG_Python_InitShadowInstance(args);
29532 }
29533
29534 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29535 PyObject *resultobj = 0;
29536 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29537 int arg2 = (int) 0 ;
29538 wxClipboardTextEvent *result = 0 ;
29539 int val1 ;
29540 int ecode1 = 0 ;
29541 int val2 ;
29542 int ecode2 = 0 ;
29543 PyObject * obj0 = 0 ;
29544 PyObject * obj1 = 0 ;
29545 char * kwnames[] = {
29546 (char *) "type",(char *) "winid", NULL
29547 };
29548
29549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29550 if (obj0) {
29551 ecode1 = SWIG_AsVal_int(obj0, &val1);
29552 if (!SWIG_IsOK(ecode1)) {
29553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29554 }
29555 arg1 = static_cast< wxEventType >(val1);
29556 }
29557 if (obj1) {
29558 ecode2 = SWIG_AsVal_int(obj1, &val2);
29559 if (!SWIG_IsOK(ecode2)) {
29560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29561 }
29562 arg2 = static_cast< int >(val2);
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29567 wxPyEndAllowThreads(__tstate);
29568 if (PyErr_Occurred()) SWIG_fail;
29569 }
29570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29571 return resultobj;
29572 fail:
29573 return NULL;
29574 }
29575
29576
29577 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29578 PyObject *obj;
29579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29580 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29581 return SWIG_Py_Void();
29582 }
29583
29584 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29585 return SWIG_Python_InitShadowInstance(args);
29586 }
29587
29588 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj = 0;
29590 int arg1 = (int) 0 ;
29591 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29592 wxPyEvent *result = 0 ;
29593 int val1 ;
29594 int ecode1 = 0 ;
29595 int val2 ;
29596 int ecode2 = 0 ;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 char * kwnames[] = {
29600 (char *) "winid",(char *) "eventType", NULL
29601 };
29602
29603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29604 if (obj0) {
29605 ecode1 = SWIG_AsVal_int(obj0, &val1);
29606 if (!SWIG_IsOK(ecode1)) {
29607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29608 }
29609 arg1 = static_cast< int >(val1);
29610 }
29611 if (obj1) {
29612 ecode2 = SWIG_AsVal_int(obj1, &val2);
29613 if (!SWIG_IsOK(ecode2)) {
29614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29615 }
29616 arg2 = static_cast< wxEventType >(val2);
29617 }
29618 {
29619 PyThreadState* __tstate = wxPyBeginAllowThreads();
29620 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29632 PyObject *resultobj = 0;
29633 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29634 void *argp1 = 0 ;
29635 int res1 = 0 ;
29636 PyObject *swig_obj[1] ;
29637
29638 if (!args) SWIG_fail;
29639 swig_obj[0] = args;
29640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29641 if (!SWIG_IsOK(res1)) {
29642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29643 }
29644 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 delete arg1;
29648
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 resultobj = SWIG_Py_Void();
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29660 PyObject *resultobj = 0;
29661 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29662 PyObject *arg2 = (PyObject *) 0 ;
29663 void *argp1 = 0 ;
29664 int res1 = 0 ;
29665 PyObject * obj0 = 0 ;
29666 PyObject * obj1 = 0 ;
29667 char * kwnames[] = {
29668 (char *) "self",(char *) "self", NULL
29669 };
29670
29671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29675 }
29676 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29677 arg2 = obj1;
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 (arg1)->SetSelf(arg2);
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 resultobj = SWIG_Py_Void();
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29692 PyObject *resultobj = 0;
29693 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29694 PyObject *result = 0 ;
29695 void *argp1 = 0 ;
29696 int res1 = 0 ;
29697 PyObject *swig_obj[1] ;
29698
29699 if (!args) SWIG_fail;
29700 swig_obj[0] = args;
29701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29702 if (!SWIG_IsOK(res1)) {
29703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29704 }
29705 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 result = (PyObject *)(arg1)->GetSelf();
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = result;
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29720 PyObject *obj;
29721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29722 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29723 return SWIG_Py_Void();
29724 }
29725
29726 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29727 return SWIG_Python_InitShadowInstance(args);
29728 }
29729
29730 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29731 PyObject *resultobj = 0;
29732 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29733 int arg2 = (int) 0 ;
29734 wxPyCommandEvent *result = 0 ;
29735 int val1 ;
29736 int ecode1 = 0 ;
29737 int val2 ;
29738 int ecode2 = 0 ;
29739 PyObject * obj0 = 0 ;
29740 PyObject * obj1 = 0 ;
29741 char * kwnames[] = {
29742 (char *) "eventType",(char *) "id", NULL
29743 };
29744
29745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29746 if (obj0) {
29747 ecode1 = SWIG_AsVal_int(obj0, &val1);
29748 if (!SWIG_IsOK(ecode1)) {
29749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29750 }
29751 arg1 = static_cast< wxEventType >(val1);
29752 }
29753 if (obj1) {
29754 ecode2 = SWIG_AsVal_int(obj1, &val2);
29755 if (!SWIG_IsOK(ecode2)) {
29756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29757 }
29758 arg2 = static_cast< int >(val2);
29759 }
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29763 wxPyEndAllowThreads(__tstate);
29764 if (PyErr_Occurred()) SWIG_fail;
29765 }
29766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29774 PyObject *resultobj = 0;
29775 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29776 void *argp1 = 0 ;
29777 int res1 = 0 ;
29778 PyObject *swig_obj[1] ;
29779
29780 if (!args) SWIG_fail;
29781 swig_obj[0] = args;
29782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29783 if (!SWIG_IsOK(res1)) {
29784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29785 }
29786 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 delete arg1;
29790
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_Py_Void();
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj = 0;
29803 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29804 PyObject *arg2 = (PyObject *) 0 ;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 PyObject * obj0 = 0 ;
29808 PyObject * obj1 = 0 ;
29809 char * kwnames[] = {
29810 (char *) "self",(char *) "self", NULL
29811 };
29812
29813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29815 if (!SWIG_IsOK(res1)) {
29816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29817 }
29818 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29819 arg2 = obj1;
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 (arg1)->SetSelf(arg2);
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 resultobj = SWIG_Py_Void();
29827 return resultobj;
29828 fail:
29829 return NULL;
29830 }
29831
29832
29833 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29834 PyObject *resultobj = 0;
29835 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29836 PyObject *result = 0 ;
29837 void *argp1 = 0 ;
29838 int res1 = 0 ;
29839 PyObject *swig_obj[1] ;
29840
29841 if (!args) SWIG_fail;
29842 swig_obj[0] = args;
29843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29846 }
29847 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = (PyObject *)(arg1)->GetSelf();
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 resultobj = result;
29855 return resultobj;
29856 fail:
29857 return NULL;
29858 }
29859
29860
29861 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29862 PyObject *obj;
29863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29864 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29865 return SWIG_Py_Void();
29866 }
29867
29868 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29869 return SWIG_Python_InitShadowInstance(args);
29870 }
29871
29872 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29873 PyObject *resultobj = 0;
29874 wxWindow *arg1 = (wxWindow *) 0 ;
29875 wxDateTime *arg2 = 0 ;
29876 wxEventType arg3 ;
29877 wxDateEvent *result = 0 ;
29878 void *argp1 = 0 ;
29879 int res1 = 0 ;
29880 void *argp2 = 0 ;
29881 int res2 = 0 ;
29882 int val3 ;
29883 int ecode3 = 0 ;
29884 PyObject * obj0 = 0 ;
29885 PyObject * obj1 = 0 ;
29886 PyObject * obj2 = 0 ;
29887 char * kwnames[] = {
29888 (char *) "win",(char *) "dt",(char *) "type", NULL
29889 };
29890
29891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29893 if (!SWIG_IsOK(res1)) {
29894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29895 }
29896 arg1 = reinterpret_cast< wxWindow * >(argp1);
29897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29898 if (!SWIG_IsOK(res2)) {
29899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29900 }
29901 if (!argp2) {
29902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29903 }
29904 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29905 ecode3 = SWIG_AsVal_int(obj2, &val3);
29906 if (!SWIG_IsOK(ecode3)) {
29907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29908 }
29909 arg3 = static_cast< wxEventType >(val3);
29910 {
29911 PyThreadState* __tstate = wxPyBeginAllowThreads();
29912 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29924 PyObject *resultobj = 0;
29925 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29926 wxDateTime *result = 0 ;
29927 void *argp1 = 0 ;
29928 int res1 = 0 ;
29929 PyObject *swig_obj[1] ;
29930
29931 if (!args) SWIG_fail;
29932 swig_obj[0] = args;
29933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29934 if (!SWIG_IsOK(res1)) {
29935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29936 }
29937 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 {
29941 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29942 result = (wxDateTime *) &_result_ref;
29943 }
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = 0;
29956 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29957 wxDateTime *arg2 = 0 ;
29958 void *argp1 = 0 ;
29959 int res1 = 0 ;
29960 void *argp2 = 0 ;
29961 int res2 = 0 ;
29962 PyObject * obj0 = 0 ;
29963 PyObject * obj1 = 0 ;
29964 char * kwnames[] = {
29965 (char *) "self",(char *) "date", NULL
29966 };
29967
29968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29970 if (!SWIG_IsOK(res1)) {
29971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29972 }
29973 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29975 if (!SWIG_IsOK(res2)) {
29976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29977 }
29978 if (!argp2) {
29979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29980 }
29981 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 (arg1)->SetDate((wxDateTime const &)*arg2);
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 resultobj = SWIG_Py_Void();
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29996 PyObject *obj;
29997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29998 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29999 return SWIG_Py_Void();
30000 }
30001
30002 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 return SWIG_Python_InitShadowInstance(args);
30004 }
30005
30006 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj = 0;
30008 wxWindow *arg1 = (wxWindow *) 0 ;
30009 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30010 wxEventBlocker *result = 0 ;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 int val2 ;
30014 int ecode2 = 0 ;
30015 PyObject * obj0 = 0 ;
30016 PyObject * obj1 = 0 ;
30017 char * kwnames[] = {
30018 (char *) "win",(char *) "type", NULL
30019 };
30020
30021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30023 if (!SWIG_IsOK(res1)) {
30024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30025 }
30026 arg1 = reinterpret_cast< wxWindow * >(argp1);
30027 if (obj1) {
30028 ecode2 = SWIG_AsVal_int(obj1, &val2);
30029 if (!SWIG_IsOK(ecode2)) {
30030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30031 }
30032 arg2 = static_cast< wxEventType >(val2);
30033 }
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30037 wxPyEndAllowThreads(__tstate);
30038 if (PyErr_Occurred()) SWIG_fail;
30039 }
30040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30048 PyObject *resultobj = 0;
30049 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30050 void *argp1 = 0 ;
30051 int res1 = 0 ;
30052 PyObject *swig_obj[1] ;
30053
30054 if (!args) SWIG_fail;
30055 swig_obj[0] = args;
30056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30057 if (!SWIG_IsOK(res1)) {
30058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30059 }
30060 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30061 {
30062 PyThreadState* __tstate = wxPyBeginAllowThreads();
30063 delete arg1;
30064
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_Py_Void();
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj = 0;
30077 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30078 wxEventType arg2 ;
30079 void *argp1 = 0 ;
30080 int res1 = 0 ;
30081 int val2 ;
30082 int ecode2 = 0 ;
30083 PyObject * obj0 = 0 ;
30084 PyObject * obj1 = 0 ;
30085 char * kwnames[] = {
30086 (char *) "self",(char *) "type", NULL
30087 };
30088
30089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30091 if (!SWIG_IsOK(res1)) {
30092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30093 }
30094 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30095 ecode2 = SWIG_AsVal_int(obj1, &val2);
30096 if (!SWIG_IsOK(ecode2)) {
30097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30098 }
30099 arg2 = static_cast< wxEventType >(val2);
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 (arg1)->Block(arg2);
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 resultobj = SWIG_Py_Void();
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30114 PyObject *obj;
30115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30116 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30117 return SWIG_Py_Void();
30118 }
30119
30120 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30121 return SWIG_Python_InitShadowInstance(args);
30122 }
30123
30124 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30125 PyObject *resultobj = 0;
30126 wxPyApp *result = 0 ;
30127
30128 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30129 {
30130 PyThreadState* __tstate = wxPyBeginAllowThreads();
30131 result = (wxPyApp *)new_wxPyApp();
30132 wxPyEndAllowThreads(__tstate);
30133 if (PyErr_Occurred()) SWIG_fail;
30134 }
30135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30143 PyObject *resultobj = 0;
30144 wxPyApp *arg1 = (wxPyApp *) 0 ;
30145 void *argp1 = 0 ;
30146 int res1 = 0 ;
30147 PyObject *swig_obj[1] ;
30148
30149 if (!args) SWIG_fail;
30150 swig_obj[0] = args;
30151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30152 if (!SWIG_IsOK(res1)) {
30153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30154 }
30155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 delete arg1;
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 resultobj = SWIG_Py_Void();
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj = 0;
30172 wxPyApp *arg1 = (wxPyApp *) 0 ;
30173 PyObject *arg2 = (PyObject *) 0 ;
30174 PyObject *arg3 = (PyObject *) 0 ;
30175 bool arg4 = (bool) false ;
30176 void *argp1 = 0 ;
30177 int res1 = 0 ;
30178 bool val4 ;
30179 int ecode4 = 0 ;
30180 PyObject * obj0 = 0 ;
30181 PyObject * obj1 = 0 ;
30182 PyObject * obj2 = 0 ;
30183 PyObject * obj3 = 0 ;
30184 char * kwnames[] = {
30185 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30186 };
30187
30188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30190 if (!SWIG_IsOK(res1)) {
30191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30192 }
30193 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30194 arg2 = obj1;
30195 arg3 = obj2;
30196 if (obj3) {
30197 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30198 if (!SWIG_IsOK(ecode4)) {
30199 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30200 }
30201 arg4 = static_cast< bool >(val4);
30202 }
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 resultobj = SWIG_Py_Void();
30210 return resultobj;
30211 fail:
30212 return NULL;
30213 }
30214
30215
30216 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30217 PyObject *resultobj = 0;
30218 wxPyApp *arg1 = (wxPyApp *) 0 ;
30219 wxString result;
30220 void *argp1 = 0 ;
30221 int res1 = 0 ;
30222 PyObject *swig_obj[1] ;
30223
30224 if (!args) SWIG_fail;
30225 swig_obj[0] = args;
30226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30227 if (!SWIG_IsOK(res1)) {
30228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30229 }
30230 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30231 {
30232 PyThreadState* __tstate = wxPyBeginAllowThreads();
30233 result = ((wxPyApp const *)arg1)->GetAppName();
30234 wxPyEndAllowThreads(__tstate);
30235 if (PyErr_Occurred()) SWIG_fail;
30236 }
30237 {
30238 #if wxUSE_UNICODE
30239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30240 #else
30241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30242 #endif
30243 }
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30251 PyObject *resultobj = 0;
30252 wxPyApp *arg1 = (wxPyApp *) 0 ;
30253 wxString *arg2 = 0 ;
30254 void *argp1 = 0 ;
30255 int res1 = 0 ;
30256 bool temp2 = false ;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 char * kwnames[] = {
30260 (char *) "self",(char *) "name", NULL
30261 };
30262
30263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30265 if (!SWIG_IsOK(res1)) {
30266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30267 }
30268 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30269 {
30270 arg2 = wxString_in_helper(obj1);
30271 if (arg2 == NULL) SWIG_fail;
30272 temp2 = true;
30273 }
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 (arg1)->SetAppName((wxString const &)*arg2);
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 resultobj = SWIG_Py_Void();
30281 {
30282 if (temp2)
30283 delete arg2;
30284 }
30285 return resultobj;
30286 fail:
30287 {
30288 if (temp2)
30289 delete arg2;
30290 }
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30296 PyObject *resultobj = 0;
30297 wxPyApp *arg1 = (wxPyApp *) 0 ;
30298 wxString result;
30299 void *argp1 = 0 ;
30300 int res1 = 0 ;
30301 PyObject *swig_obj[1] ;
30302
30303 if (!args) SWIG_fail;
30304 swig_obj[0] = args;
30305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30306 if (!SWIG_IsOK(res1)) {
30307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30308 }
30309 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30310 {
30311 PyThreadState* __tstate = wxPyBeginAllowThreads();
30312 result = ((wxPyApp const *)arg1)->GetClassName();
30313 wxPyEndAllowThreads(__tstate);
30314 if (PyErr_Occurred()) SWIG_fail;
30315 }
30316 {
30317 #if wxUSE_UNICODE
30318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30319 #else
30320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30321 #endif
30322 }
30323 return resultobj;
30324 fail:
30325 return NULL;
30326 }
30327
30328
30329 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30330 PyObject *resultobj = 0;
30331 wxPyApp *arg1 = (wxPyApp *) 0 ;
30332 wxString *arg2 = 0 ;
30333 void *argp1 = 0 ;
30334 int res1 = 0 ;
30335 bool temp2 = false ;
30336 PyObject * obj0 = 0 ;
30337 PyObject * obj1 = 0 ;
30338 char * kwnames[] = {
30339 (char *) "self",(char *) "name", NULL
30340 };
30341
30342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30344 if (!SWIG_IsOK(res1)) {
30345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30346 }
30347 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30348 {
30349 arg2 = wxString_in_helper(obj1);
30350 if (arg2 == NULL) SWIG_fail;
30351 temp2 = true;
30352 }
30353 {
30354 PyThreadState* __tstate = wxPyBeginAllowThreads();
30355 (arg1)->SetClassName((wxString const &)*arg2);
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 resultobj = SWIG_Py_Void();
30360 {
30361 if (temp2)
30362 delete arg2;
30363 }
30364 return resultobj;
30365 fail:
30366 {
30367 if (temp2)
30368 delete arg2;
30369 }
30370 return NULL;
30371 }
30372
30373
30374 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30375 PyObject *resultobj = 0;
30376 wxPyApp *arg1 = (wxPyApp *) 0 ;
30377 wxString *result = 0 ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 PyObject *swig_obj[1] ;
30381
30382 if (!args) SWIG_fail;
30383 swig_obj[0] = args;
30384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30385 if (!SWIG_IsOK(res1)) {
30386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30387 }
30388 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 {
30392 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30393 result = (wxString *) &_result_ref;
30394 }
30395 wxPyEndAllowThreads(__tstate);
30396 if (PyErr_Occurred()) SWIG_fail;
30397 }
30398 {
30399 #if wxUSE_UNICODE
30400 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30401 #else
30402 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30403 #endif
30404 }
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30412 PyObject *resultobj = 0;
30413 wxPyApp *arg1 = (wxPyApp *) 0 ;
30414 wxString *arg2 = 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 bool temp2 = false ;
30418 PyObject * obj0 = 0 ;
30419 PyObject * obj1 = 0 ;
30420 char * kwnames[] = {
30421 (char *) "self",(char *) "name", NULL
30422 };
30423
30424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30426 if (!SWIG_IsOK(res1)) {
30427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30428 }
30429 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30430 {
30431 arg2 = wxString_in_helper(obj1);
30432 if (arg2 == NULL) SWIG_fail;
30433 temp2 = true;
30434 }
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 (arg1)->SetVendorName((wxString const &)*arg2);
30438 wxPyEndAllowThreads(__tstate);
30439 if (PyErr_Occurred()) SWIG_fail;
30440 }
30441 resultobj = SWIG_Py_Void();
30442 {
30443 if (temp2)
30444 delete arg2;
30445 }
30446 return resultobj;
30447 fail:
30448 {
30449 if (temp2)
30450 delete arg2;
30451 }
30452 return NULL;
30453 }
30454
30455
30456 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30457 PyObject *resultobj = 0;
30458 wxPyApp *arg1 = (wxPyApp *) 0 ;
30459 wxAppTraits *result = 0 ;
30460 void *argp1 = 0 ;
30461 int res1 = 0 ;
30462 PyObject *swig_obj[1] ;
30463
30464 if (!args) SWIG_fail;
30465 swig_obj[0] = args;
30466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30467 if (!SWIG_IsOK(res1)) {
30468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30469 }
30470 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (wxAppTraits *)(arg1)->GetTraits();
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30485 PyObject *resultobj = 0;
30486 wxPyApp *arg1 = (wxPyApp *) 0 ;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 PyObject *swig_obj[1] ;
30490
30491 if (!args) SWIG_fail;
30492 swig_obj[0] = args;
30493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30494 if (!SWIG_IsOK(res1)) {
30495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30496 }
30497 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 (arg1)->ProcessPendingEvents();
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 resultobj = SWIG_Py_Void();
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj = 0;
30513 wxPyApp *arg1 = (wxPyApp *) 0 ;
30514 bool arg2 = (bool) false ;
30515 bool result;
30516 void *argp1 = 0 ;
30517 int res1 = 0 ;
30518 bool val2 ;
30519 int ecode2 = 0 ;
30520 PyObject * obj0 = 0 ;
30521 PyObject * obj1 = 0 ;
30522 char * kwnames[] = {
30523 (char *) "self",(char *) "onlyIfNeeded", NULL
30524 };
30525
30526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30528 if (!SWIG_IsOK(res1)) {
30529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30530 }
30531 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30532 if (obj1) {
30533 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30534 if (!SWIG_IsOK(ecode2)) {
30535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30536 }
30537 arg2 = static_cast< bool >(val2);
30538 }
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 result = (bool)(arg1)->Yield(arg2);
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 {
30546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30547 }
30548 return resultobj;
30549 fail:
30550 return NULL;
30551 }
30552
30553
30554 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30555 PyObject *resultobj = 0;
30556 wxPyApp *arg1 = (wxPyApp *) 0 ;
30557 void *argp1 = 0 ;
30558 int res1 = 0 ;
30559 PyObject *swig_obj[1] ;
30560
30561 if (!args) SWIG_fail;
30562 swig_obj[0] = args;
30563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30566 }
30567 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->WakeUpIdle();
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30582 PyObject *resultobj = 0;
30583 bool result;
30584
30585 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 result = (bool)wxPyApp::IsMainLoopRunning();
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 {
30593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30594 }
30595 return resultobj;
30596 fail:
30597 return NULL;
30598 }
30599
30600
30601 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30602 PyObject *resultobj = 0;
30603 wxPyApp *arg1 = (wxPyApp *) 0 ;
30604 int result;
30605 void *argp1 = 0 ;
30606 int res1 = 0 ;
30607 PyObject *swig_obj[1] ;
30608
30609 if (!args) SWIG_fail;
30610 swig_obj[0] = args;
30611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30612 if (!SWIG_IsOK(res1)) {
30613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30614 }
30615 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 result = (int)(arg1)->MainLoop();
30619 wxPyEndAllowThreads(__tstate);
30620 if (PyErr_Occurred()) SWIG_fail;
30621 }
30622 resultobj = SWIG_From_int(static_cast< int >(result));
30623 return resultobj;
30624 fail:
30625 return NULL;
30626 }
30627
30628
30629 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30630 PyObject *resultobj = 0;
30631 wxPyApp *arg1 = (wxPyApp *) 0 ;
30632 void *argp1 = 0 ;
30633 int res1 = 0 ;
30634 PyObject *swig_obj[1] ;
30635
30636 if (!args) SWIG_fail;
30637 swig_obj[0] = args;
30638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30639 if (!SWIG_IsOK(res1)) {
30640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30641 }
30642 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30643 {
30644 PyThreadState* __tstate = wxPyBeginAllowThreads();
30645 (arg1)->Exit();
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 resultobj = SWIG_Py_Void();
30650 return resultobj;
30651 fail:
30652 return NULL;
30653 }
30654
30655
30656 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30657 PyObject *resultobj = 0;
30658 wxPyApp *arg1 = (wxPyApp *) 0 ;
30659 wxLayoutDirection result;
30660 void *argp1 = 0 ;
30661 int res1 = 0 ;
30662 PyObject *swig_obj[1] ;
30663
30664 if (!args) SWIG_fail;
30665 swig_obj[0] = args;
30666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30667 if (!SWIG_IsOK(res1)) {
30668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30669 }
30670 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_From_int(static_cast< int >(result));
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30685 PyObject *resultobj = 0;
30686 wxPyApp *arg1 = (wxPyApp *) 0 ;
30687 void *argp1 = 0 ;
30688 int res1 = 0 ;
30689 PyObject *swig_obj[1] ;
30690
30691 if (!args) SWIG_fail;
30692 swig_obj[0] = args;
30693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30694 if (!SWIG_IsOK(res1)) {
30695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30696 }
30697 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30698 {
30699 PyThreadState* __tstate = wxPyBeginAllowThreads();
30700 (arg1)->ExitMainLoop();
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 resultobj = SWIG_Py_Void();
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30712 PyObject *resultobj = 0;
30713 wxPyApp *arg1 = (wxPyApp *) 0 ;
30714 bool result;
30715 void *argp1 = 0 ;
30716 int res1 = 0 ;
30717 PyObject *swig_obj[1] ;
30718
30719 if (!args) SWIG_fail;
30720 swig_obj[0] = args;
30721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30722 if (!SWIG_IsOK(res1)) {
30723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30724 }
30725 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 result = (bool)(arg1)->Pending();
30729 wxPyEndAllowThreads(__tstate);
30730 if (PyErr_Occurred()) SWIG_fail;
30731 }
30732 {
30733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30734 }
30735 return resultobj;
30736 fail:
30737 return NULL;
30738 }
30739
30740
30741 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30742 PyObject *resultobj = 0;
30743 wxPyApp *arg1 = (wxPyApp *) 0 ;
30744 bool result;
30745 void *argp1 = 0 ;
30746 int res1 = 0 ;
30747 PyObject *swig_obj[1] ;
30748
30749 if (!args) SWIG_fail;
30750 swig_obj[0] = args;
30751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30752 if (!SWIG_IsOK(res1)) {
30753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30754 }
30755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 result = (bool)(arg1)->Dispatch();
30759 wxPyEndAllowThreads(__tstate);
30760 if (PyErr_Occurred()) SWIG_fail;
30761 }
30762 {
30763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30764 }
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 PyObject *resultobj = 0;
30773 wxPyApp *arg1 = (wxPyApp *) 0 ;
30774 bool result;
30775 void *argp1 = 0 ;
30776 int res1 = 0 ;
30777 PyObject *swig_obj[1] ;
30778
30779 if (!args) SWIG_fail;
30780 swig_obj[0] = args;
30781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30782 if (!SWIG_IsOK(res1)) {
30783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30784 }
30785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (bool)(arg1)->ProcessIdle();
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 {
30793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30794 }
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj = 0;
30803 wxPyApp *arg1 = (wxPyApp *) 0 ;
30804 wxWindow *arg2 = (wxWindow *) 0 ;
30805 wxIdleEvent *arg3 = 0 ;
30806 bool result;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 void *argp2 = 0 ;
30810 int res2 = 0 ;
30811 void *argp3 = 0 ;
30812 int res3 = 0 ;
30813 PyObject * obj0 = 0 ;
30814 PyObject * obj1 = 0 ;
30815 PyObject * obj2 = 0 ;
30816 char * kwnames[] = {
30817 (char *) "self",(char *) "win",(char *) "event", NULL
30818 };
30819
30820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30822 if (!SWIG_IsOK(res1)) {
30823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30824 }
30825 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30826 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30827 if (!SWIG_IsOK(res2)) {
30828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30829 }
30830 arg2 = reinterpret_cast< wxWindow * >(argp2);
30831 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30832 if (!SWIG_IsOK(res3)) {
30833 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30834 }
30835 if (!argp3) {
30836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30837 }
30838 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 {
30846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30847 }
30848 return resultobj;
30849 fail:
30850 return NULL;
30851 }
30852
30853
30854 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30855 PyObject *resultobj = 0;
30856 wxPyApp *arg1 = (wxPyApp *) 0 ;
30857 bool result;
30858 void *argp1 = 0 ;
30859 int res1 = 0 ;
30860 PyObject *swig_obj[1] ;
30861
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30867 }
30868 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 result = (bool)((wxPyApp const *)arg1)->IsActive();
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 {
30876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30877 }
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30885 PyObject *resultobj = 0;
30886 wxPyApp *arg1 = (wxPyApp *) 0 ;
30887 wxWindow *arg2 = (wxWindow *) 0 ;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 void *argp2 = 0 ;
30891 int res2 = 0 ;
30892 PyObject * obj0 = 0 ;
30893 PyObject * obj1 = 0 ;
30894 char * kwnames[] = {
30895 (char *) "self",(char *) "win", NULL
30896 };
30897
30898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30900 if (!SWIG_IsOK(res1)) {
30901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30902 }
30903 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30904 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res2)) {
30906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30907 }
30908 arg2 = reinterpret_cast< wxWindow * >(argp2);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 (arg1)->SetTopWindow(arg2);
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = SWIG_Py_Void();
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30923 PyObject *resultobj = 0;
30924 wxPyApp *arg1 = (wxPyApp *) 0 ;
30925 wxWindow *result = 0 ;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 PyObject *swig_obj[1] ;
30929
30930 if (!args) SWIG_fail;
30931 swig_obj[0] = args;
30932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30935 }
30936 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 {
30944 resultobj = wxPyMake_wxObject(result, (bool)0);
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj = 0;
30954 wxPyApp *arg1 = (wxPyApp *) 0 ;
30955 bool arg2 ;
30956 void *argp1 = 0 ;
30957 int res1 = 0 ;
30958 bool val2 ;
30959 int ecode2 = 0 ;
30960 PyObject * obj0 = 0 ;
30961 PyObject * obj1 = 0 ;
30962 char * kwnames[] = {
30963 (char *) "self",(char *) "flag", NULL
30964 };
30965
30966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30968 if (!SWIG_IsOK(res1)) {
30969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30970 }
30971 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30972 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30973 if (!SWIG_IsOK(ecode2)) {
30974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30975 }
30976 arg2 = static_cast< bool >(val2);
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 (arg1)->SetExitOnFrameDelete(arg2);
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 resultobj = SWIG_Py_Void();
30984 return resultobj;
30985 fail:
30986 return NULL;
30987 }
30988
30989
30990 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30991 PyObject *resultobj = 0;
30992 wxPyApp *arg1 = (wxPyApp *) 0 ;
30993 bool result;
30994 void *argp1 = 0 ;
30995 int res1 = 0 ;
30996 PyObject *swig_obj[1] ;
30997
30998 if (!args) SWIG_fail;
30999 swig_obj[0] = args;
31000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31001 if (!SWIG_IsOK(res1)) {
31002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31003 }
31004 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 {
31012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31013 }
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj = 0;
31022 wxPyApp *arg1 = (wxPyApp *) 0 ;
31023 bool arg2 ;
31024 bool arg3 = (bool) false ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 bool val2 ;
31028 int ecode2 = 0 ;
31029 bool val3 ;
31030 int ecode3 = 0 ;
31031 PyObject * obj0 = 0 ;
31032 PyObject * obj1 = 0 ;
31033 PyObject * obj2 = 0 ;
31034 char * kwnames[] = {
31035 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31036 };
31037
31038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31042 }
31043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31045 if (!SWIG_IsOK(ecode2)) {
31046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31047 }
31048 arg2 = static_cast< bool >(val2);
31049 if (obj2) {
31050 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31051 if (!SWIG_IsOK(ecode3)) {
31052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31053 }
31054 arg3 = static_cast< bool >(val3);
31055 }
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 (arg1)->SetUseBestVisual(arg2,arg3);
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 resultobj = SWIG_Py_Void();
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 PyObject *resultobj = 0;
31071 wxPyApp *arg1 = (wxPyApp *) 0 ;
31072 bool result;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 PyObject *swig_obj[1] ;
31076
31077 if (!args) SWIG_fail;
31078 swig_obj[0] = args;
31079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31080 if (!SWIG_IsOK(res1)) {
31081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31082 }
31083 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 {
31091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31092 }
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = 0;
31101 wxPyApp *arg1 = (wxPyApp *) 0 ;
31102 int arg2 ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 int val2 ;
31106 int ecode2 = 0 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 char * kwnames[] = {
31110 (char *) "self",(char *) "mode", NULL
31111 };
31112
31113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31117 }
31118 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31119 ecode2 = SWIG_AsVal_int(obj1, &val2);
31120 if (!SWIG_IsOK(ecode2)) {
31121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31122 }
31123 arg2 = static_cast< int >(val2);
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 (arg1)->SetPrintMode(arg2);
31127 wxPyEndAllowThreads(__tstate);
31128 if (PyErr_Occurred()) SWIG_fail;
31129 }
31130 resultobj = SWIG_Py_Void();
31131 return resultobj;
31132 fail:
31133 return NULL;
31134 }
31135
31136
31137 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31138 PyObject *resultobj = 0;
31139 wxPyApp *arg1 = (wxPyApp *) 0 ;
31140 int result;
31141 void *argp1 = 0 ;
31142 int res1 = 0 ;
31143 PyObject *swig_obj[1] ;
31144
31145 if (!args) SWIG_fail;
31146 swig_obj[0] = args;
31147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31148 if (!SWIG_IsOK(res1)) {
31149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31150 }
31151 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 resultobj = SWIG_From_int(static_cast< int >(result));
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31166 PyObject *resultobj = 0;
31167 wxPyApp *arg1 = (wxPyApp *) 0 ;
31168 int arg2 ;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 int val2 ;
31172 int ecode2 = 0 ;
31173 PyObject * obj0 = 0 ;
31174 PyObject * obj1 = 0 ;
31175 char * kwnames[] = {
31176 (char *) "self",(char *) "mode", NULL
31177 };
31178
31179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31181 if (!SWIG_IsOK(res1)) {
31182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31183 }
31184 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31185 ecode2 = SWIG_AsVal_int(obj1, &val2);
31186 if (!SWIG_IsOK(ecode2)) {
31187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31188 }
31189 arg2 = static_cast< int >(val2);
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 (arg1)->SetAssertMode(arg2);
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 resultobj = SWIG_Py_Void();
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31204 PyObject *resultobj = 0;
31205 wxPyApp *arg1 = (wxPyApp *) 0 ;
31206 int result;
31207 void *argp1 = 0 ;
31208 int res1 = 0 ;
31209 PyObject *swig_obj[1] ;
31210
31211 if (!args) SWIG_fail;
31212 swig_obj[0] = args;
31213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31214 if (!SWIG_IsOK(res1)) {
31215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31216 }
31217 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 result = (int)(arg1)->GetAssertMode();
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 resultobj = SWIG_From_int(static_cast< int >(result));
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 PyObject *resultobj = 0;
31233 bool result;
31234
31235 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 {
31243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31244 }
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31252 PyObject *resultobj = 0;
31253 long result;
31254
31255 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31256 {
31257 PyThreadState* __tstate = wxPyBeginAllowThreads();
31258 result = (long)wxPyApp::GetMacAboutMenuItemId();
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 resultobj = SWIG_From_long(static_cast< long >(result));
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31270 PyObject *resultobj = 0;
31271 long result;
31272
31273 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31274 {
31275 PyThreadState* __tstate = wxPyBeginAllowThreads();
31276 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 resultobj = SWIG_From_long(static_cast< long >(result));
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31288 PyObject *resultobj = 0;
31289 long result;
31290
31291 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = (long)wxPyApp::GetMacExitMenuItemId();
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_From_long(static_cast< long >(result));
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31306 PyObject *resultobj = 0;
31307 wxString result;
31308
31309 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31310 {
31311 PyThreadState* __tstate = wxPyBeginAllowThreads();
31312 result = wxPyApp::GetMacHelpMenuTitleName();
31313 wxPyEndAllowThreads(__tstate);
31314 if (PyErr_Occurred()) SWIG_fail;
31315 }
31316 {
31317 #if wxUSE_UNICODE
31318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31319 #else
31320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31321 #endif
31322 }
31323 return resultobj;
31324 fail:
31325 return NULL;
31326 }
31327
31328
31329 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31330 PyObject *resultobj = 0;
31331 bool arg1 ;
31332 bool val1 ;
31333 int ecode1 = 0 ;
31334 PyObject * obj0 = 0 ;
31335 char * kwnames[] = {
31336 (char *) "val", NULL
31337 };
31338
31339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31340 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31341 if (!SWIG_IsOK(ecode1)) {
31342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31343 }
31344 arg1 = static_cast< bool >(val1);
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_Py_Void();
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj = 0;
31360 long arg1 ;
31361 long val1 ;
31362 int ecode1 = 0 ;
31363 PyObject * obj0 = 0 ;
31364 char * kwnames[] = {
31365 (char *) "val", NULL
31366 };
31367
31368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31369 ecode1 = SWIG_AsVal_long(obj0, &val1);
31370 if (!SWIG_IsOK(ecode1)) {
31371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31372 }
31373 arg1 = static_cast< long >(val1);
31374 {
31375 PyThreadState* __tstate = wxPyBeginAllowThreads();
31376 wxPyApp::SetMacAboutMenuItemId(arg1);
31377 wxPyEndAllowThreads(__tstate);
31378 if (PyErr_Occurred()) SWIG_fail;
31379 }
31380 resultobj = SWIG_Py_Void();
31381 return resultobj;
31382 fail:
31383 return NULL;
31384 }
31385
31386
31387 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31388 PyObject *resultobj = 0;
31389 long arg1 ;
31390 long val1 ;
31391 int ecode1 = 0 ;
31392 PyObject * obj0 = 0 ;
31393 char * kwnames[] = {
31394 (char *) "val", NULL
31395 };
31396
31397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31398 ecode1 = SWIG_AsVal_long(obj0, &val1);
31399 if (!SWIG_IsOK(ecode1)) {
31400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31401 }
31402 arg1 = static_cast< long >(val1);
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 resultobj = SWIG_Py_Void();
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31417 PyObject *resultobj = 0;
31418 long arg1 ;
31419 long val1 ;
31420 int ecode1 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 char * kwnames[] = {
31423 (char *) "val", NULL
31424 };
31425
31426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31427 ecode1 = SWIG_AsVal_long(obj0, &val1);
31428 if (!SWIG_IsOK(ecode1)) {
31429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31430 }
31431 arg1 = static_cast< long >(val1);
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 wxPyApp::SetMacExitMenuItemId(arg1);
31435 wxPyEndAllowThreads(__tstate);
31436 if (PyErr_Occurred()) SWIG_fail;
31437 }
31438 resultobj = SWIG_Py_Void();
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj = 0;
31447 wxString *arg1 = 0 ;
31448 bool temp1 = false ;
31449 PyObject * obj0 = 0 ;
31450 char * kwnames[] = {
31451 (char *) "val", NULL
31452 };
31453
31454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31455 {
31456 arg1 = wxString_in_helper(obj0);
31457 if (arg1 == NULL) SWIG_fail;
31458 temp1 = true;
31459 }
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 resultobj = SWIG_Py_Void();
31467 {
31468 if (temp1)
31469 delete arg1;
31470 }
31471 return resultobj;
31472 fail:
31473 {
31474 if (temp1)
31475 delete arg1;
31476 }
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 PyObject *resultobj = 0;
31483 wxPyApp *arg1 = (wxPyApp *) 0 ;
31484 void *argp1 = 0 ;
31485 int res1 = 0 ;
31486 PyObject *swig_obj[1] ;
31487
31488 if (!args) SWIG_fail;
31489 swig_obj[0] = args;
31490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31491 if (!SWIG_IsOK(res1)) {
31492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31493 }
31494 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 (arg1)->_BootstrapApp();
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 resultobj = SWIG_Py_Void();
31502 return resultobj;
31503 fail:
31504 return NULL;
31505 }
31506
31507
31508 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31509 PyObject *resultobj = 0;
31510 int result;
31511
31512 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31513 {
31514 PyThreadState* __tstate = wxPyBeginAllowThreads();
31515 result = (int)wxPyApp_GetComCtl32Version();
31516 wxPyEndAllowThreads(__tstate);
31517 if (PyErr_Occurred()) SWIG_fail;
31518 }
31519 resultobj = SWIG_From_int(static_cast< int >(result));
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31527 PyObject *resultobj = 0;
31528 bool result;
31529
31530 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 result = (bool)wxPyApp_IsDisplayAvailable();
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 {
31538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31539 }
31540 return resultobj;
31541 fail:
31542 return NULL;
31543 }
31544
31545
31546 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31547 PyObject *obj;
31548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31549 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31550 return SWIG_Py_Void();
31551 }
31552
31553 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31554 return SWIG_Python_InitShadowInstance(args);
31555 }
31556
31557 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31558 PyObject *resultobj = 0;
31559
31560 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 wxExit();
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_Py_Void();
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31575 PyObject *resultobj = 0;
31576 bool result;
31577
31578 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 result = (bool)wxYield();
31582 wxPyEndAllowThreads(__tstate);
31583 if (PyErr_Occurred()) SWIG_fail;
31584 }
31585 {
31586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31587 }
31588 return resultobj;
31589 fail:
31590 return NULL;
31591 }
31592
31593
31594 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31595 PyObject *resultobj = 0;
31596 bool result;
31597
31598 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 result = (bool)wxYieldIfNeeded();
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 {
31606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31607 }
31608 return resultobj;
31609 fail:
31610 return NULL;
31611 }
31612
31613
31614 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj = 0;
31616 wxWindow *arg1 = (wxWindow *) NULL ;
31617 bool arg2 = (bool) false ;
31618 bool result;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 bool val2 ;
31622 int ecode2 = 0 ;
31623 PyObject * obj0 = 0 ;
31624 PyObject * obj1 = 0 ;
31625 char * kwnames[] = {
31626 (char *) "win",(char *) "onlyIfNeeded", NULL
31627 };
31628
31629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31630 if (obj0) {
31631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31632 if (!SWIG_IsOK(res1)) {
31633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31634 }
31635 arg1 = reinterpret_cast< wxWindow * >(argp1);
31636 }
31637 if (obj1) {
31638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31639 if (!SWIG_IsOK(ecode2)) {
31640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31641 }
31642 arg2 = static_cast< bool >(val2);
31643 }
31644 {
31645 PyThreadState* __tstate = wxPyBeginAllowThreads();
31646 result = (bool)wxSafeYield(arg1,arg2);
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 {
31651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31652 }
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31660 PyObject *resultobj = 0;
31661
31662 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 wxWakeUpIdle();
31666 wxPyEndAllowThreads(__tstate);
31667 if (PyErr_Occurred()) SWIG_fail;
31668 }
31669 resultobj = SWIG_Py_Void();
31670 return resultobj;
31671 fail:
31672 return NULL;
31673 }
31674
31675
31676 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31677 PyObject *resultobj = 0;
31678 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31679 wxEvent *arg2 = 0 ;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 void *argp2 = 0 ;
31683 int res2 = 0 ;
31684 PyObject * obj0 = 0 ;
31685 PyObject * obj1 = 0 ;
31686 char * kwnames[] = {
31687 (char *) "dest",(char *) "event", NULL
31688 };
31689
31690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31692 if (!SWIG_IsOK(res1)) {
31693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31694 }
31695 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31696 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31697 if (!SWIG_IsOK(res2)) {
31698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31699 }
31700 if (!argp2) {
31701 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31702 }
31703 arg2 = reinterpret_cast< wxEvent * >(argp2);
31704 {
31705 PyThreadState* __tstate = wxPyBeginAllowThreads();
31706 wxPostEvent(arg1,*arg2);
31707 wxPyEndAllowThreads(__tstate);
31708 if (PyErr_Occurred()) SWIG_fail;
31709 }
31710 resultobj = SWIG_Py_Void();
31711 return resultobj;
31712 fail:
31713 return NULL;
31714 }
31715
31716
31717 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31718 PyObject *resultobj = 0;
31719
31720 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31721 {
31722 PyThreadState* __tstate = wxPyBeginAllowThreads();
31723 wxApp_CleanUp();
31724 wxPyEndAllowThreads(__tstate);
31725 if (PyErr_Occurred()) SWIG_fail;
31726 }
31727 resultobj = SWIG_Py_Void();
31728 return resultobj;
31729 fail:
31730 return NULL;
31731 }
31732
31733
31734 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31735 PyObject *resultobj = 0;
31736 wxPyApp *result = 0 ;
31737
31738 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 result = (wxPyApp *)wxPyGetApp();
31742 wxPyEndAllowThreads(__tstate);
31743 if (PyErr_Occurred()) SWIG_fail;
31744 }
31745 {
31746 resultobj = wxPyMake_wxObject(result, 0);
31747 }
31748 return resultobj;
31749 fail:
31750 return NULL;
31751 }
31752
31753
31754 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31755 PyObject *resultobj = 0;
31756 char *arg1 = (char *) 0 ;
31757 int res1 ;
31758 char *buf1 = 0 ;
31759 int alloc1 = 0 ;
31760 PyObject * obj0 = 0 ;
31761 char * kwnames[] = {
31762 (char *) "encoding", NULL
31763 };
31764
31765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31766 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31769 }
31770 arg1 = buf1;
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 wxSetDefaultPyEncoding((char const *)arg1);
31774 wxPyEndAllowThreads(__tstate);
31775 if (PyErr_Occurred()) SWIG_fail;
31776 }
31777 resultobj = SWIG_Py_Void();
31778 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31779 return resultobj;
31780 fail:
31781 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 char *result = 0 ;
31789
31790 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 result = (char *)wxGetDefaultPyEncoding();
31794 wxPyEndAllowThreads(__tstate);
31795 if (PyErr_Occurred()) SWIG_fail;
31796 }
31797 resultobj = SWIG_FromCharPtr(result);
31798 return resultobj;
31799 fail:
31800 return NULL;
31801 }
31802
31803
31804 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31805 PyObject *resultobj = 0;
31806 wxEventLoop *result = 0 ;
31807
31808 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 result = (wxEventLoop *)new wxEventLoop();
31812 wxPyEndAllowThreads(__tstate);
31813 if (PyErr_Occurred()) SWIG_fail;
31814 }
31815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31816 return resultobj;
31817 fail:
31818 return NULL;
31819 }
31820
31821
31822 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31823 PyObject *resultobj = 0;
31824 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31825 void *argp1 = 0 ;
31826 int res1 = 0 ;
31827 PyObject *swig_obj[1] ;
31828
31829 if (!args) SWIG_fail;
31830 swig_obj[0] = args;
31831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31834 }
31835 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31836 {
31837 PyThreadState* __tstate = wxPyBeginAllowThreads();
31838 delete arg1;
31839
31840 wxPyEndAllowThreads(__tstate);
31841 if (PyErr_Occurred()) SWIG_fail;
31842 }
31843 resultobj = SWIG_Py_Void();
31844 return resultobj;
31845 fail:
31846 return NULL;
31847 }
31848
31849
31850 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31851 PyObject *resultobj = 0;
31852 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31853 int result;
31854 void *argp1 = 0 ;
31855 int res1 = 0 ;
31856 PyObject *swig_obj[1] ;
31857
31858 if (!args) SWIG_fail;
31859 swig_obj[0] = args;
31860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31861 if (!SWIG_IsOK(res1)) {
31862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31863 }
31864 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 result = (int)(arg1)->Run();
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 resultobj = SWIG_From_int(static_cast< int >(result));
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31879 PyObject *resultobj = 0;
31880 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31881 int arg2 = (int) 0 ;
31882 void *argp1 = 0 ;
31883 int res1 = 0 ;
31884 int val2 ;
31885 int ecode2 = 0 ;
31886 PyObject * obj0 = 0 ;
31887 PyObject * obj1 = 0 ;
31888 char * kwnames[] = {
31889 (char *) "self",(char *) "rc", NULL
31890 };
31891
31892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31894 if (!SWIG_IsOK(res1)) {
31895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31896 }
31897 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31898 if (obj1) {
31899 ecode2 = SWIG_AsVal_int(obj1, &val2);
31900 if (!SWIG_IsOK(ecode2)) {
31901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31902 }
31903 arg2 = static_cast< int >(val2);
31904 }
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 (arg1)->Exit(arg2);
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_Py_Void();
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31919 PyObject *resultobj = 0;
31920 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31921 bool result;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 PyObject *swig_obj[1] ;
31925
31926 if (!args) SWIG_fail;
31927 swig_obj[0] = args;
31928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31931 }
31932 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = (bool)((wxEventLoop const *)arg1)->Pending();
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 {
31940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31941 }
31942 return resultobj;
31943 fail:
31944 return NULL;
31945 }
31946
31947
31948 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31949 PyObject *resultobj = 0;
31950 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31951 bool result;
31952 void *argp1 = 0 ;
31953 int res1 = 0 ;
31954 PyObject *swig_obj[1] ;
31955
31956 if (!args) SWIG_fail;
31957 swig_obj[0] = args;
31958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31959 if (!SWIG_IsOK(res1)) {
31960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31961 }
31962 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31963 {
31964 PyThreadState* __tstate = wxPyBeginAllowThreads();
31965 result = (bool)(arg1)->Dispatch();
31966 wxPyEndAllowThreads(__tstate);
31967 if (PyErr_Occurred()) SWIG_fail;
31968 }
31969 {
31970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31971 }
31972 return resultobj;
31973 fail:
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31979 PyObject *resultobj = 0;
31980 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31981 bool result;
31982 void *argp1 = 0 ;
31983 int res1 = 0 ;
31984 PyObject *swig_obj[1] ;
31985
31986 if (!args) SWIG_fail;
31987 swig_obj[0] = args;
31988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31989 if (!SWIG_IsOK(res1)) {
31990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31991 }
31992 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 {
32000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32001 }
32002 return resultobj;
32003 fail:
32004 return NULL;
32005 }
32006
32007
32008 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32009 PyObject *resultobj = 0;
32010 wxEventLoop *result = 0 ;
32011
32012 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32013 {
32014 PyThreadState* __tstate = wxPyBeginAllowThreads();
32015 result = (wxEventLoop *)wxEventLoop::GetActive();
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32020 return resultobj;
32021 fail:
32022 return NULL;
32023 }
32024
32025
32026 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32027 PyObject *resultobj = 0;
32028 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32029 void *argp1 = 0 ;
32030 int res1 = 0 ;
32031 PyObject * obj0 = 0 ;
32032 char * kwnames[] = {
32033 (char *) "loop", NULL
32034 };
32035
32036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32038 if (!SWIG_IsOK(res1)) {
32039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32040 }
32041 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32042 {
32043 PyThreadState* __tstate = wxPyBeginAllowThreads();
32044 wxEventLoop::SetActive(arg1);
32045 wxPyEndAllowThreads(__tstate);
32046 if (PyErr_Occurred()) SWIG_fail;
32047 }
32048 resultobj = SWIG_Py_Void();
32049 return resultobj;
32050 fail:
32051 return NULL;
32052 }
32053
32054
32055 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32056 PyObject *obj;
32057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32058 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32059 return SWIG_Py_Void();
32060 }
32061
32062 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32063 return SWIG_Python_InitShadowInstance(args);
32064 }
32065
32066 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32067 PyObject *resultobj = 0;
32068 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32069 wxEventLoopActivator *result = 0 ;
32070 void *argp1 = 0 ;
32071 int res1 = 0 ;
32072 PyObject * obj0 = 0 ;
32073 char * kwnames[] = {
32074 (char *) "evtLoop", NULL
32075 };
32076
32077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32079 if (!SWIG_IsOK(res1)) {
32080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32081 }
32082 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32086 wxPyEndAllowThreads(__tstate);
32087 if (PyErr_Occurred()) SWIG_fail;
32088 }
32089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32097 PyObject *resultobj = 0;
32098 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32099 void *argp1 = 0 ;
32100 int res1 = 0 ;
32101 PyObject *swig_obj[1] ;
32102
32103 if (!args) SWIG_fail;
32104 swig_obj[0] = args;
32105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32106 if (!SWIG_IsOK(res1)) {
32107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32108 }
32109 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32110 {
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 delete arg1;
32113
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 resultobj = SWIG_Py_Void();
32118 return resultobj;
32119 fail:
32120 return NULL;
32121 }
32122
32123
32124 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32125 PyObject *obj;
32126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32127 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32128 return SWIG_Py_Void();
32129 }
32130
32131 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 return SWIG_Python_InitShadowInstance(args);
32133 }
32134
32135 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32136 PyObject *resultobj = 0;
32137 int arg1 = (int) 0 ;
32138 int arg2 = (int) 0 ;
32139 int arg3 = (int) 0 ;
32140 wxAcceleratorEntry *result = 0 ;
32141 int val1 ;
32142 int ecode1 = 0 ;
32143 int val2 ;
32144 int ecode2 = 0 ;
32145 int val3 ;
32146 int ecode3 = 0 ;
32147 PyObject * obj0 = 0 ;
32148 PyObject * obj1 = 0 ;
32149 PyObject * obj2 = 0 ;
32150 char * kwnames[] = {
32151 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32152 };
32153
32154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32155 if (obj0) {
32156 ecode1 = SWIG_AsVal_int(obj0, &val1);
32157 if (!SWIG_IsOK(ecode1)) {
32158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32159 }
32160 arg1 = static_cast< int >(val1);
32161 }
32162 if (obj1) {
32163 ecode2 = SWIG_AsVal_int(obj1, &val2);
32164 if (!SWIG_IsOK(ecode2)) {
32165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32166 }
32167 arg2 = static_cast< int >(val2);
32168 }
32169 if (obj2) {
32170 ecode3 = SWIG_AsVal_int(obj2, &val3);
32171 if (!SWIG_IsOK(ecode3)) {
32172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32173 }
32174 arg3 = static_cast< int >(val3);
32175 }
32176 {
32177 PyThreadState* __tstate = wxPyBeginAllowThreads();
32178 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32179 wxPyEndAllowThreads(__tstate);
32180 if (PyErr_Occurred()) SWIG_fail;
32181 }
32182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32183 return resultobj;
32184 fail:
32185 return NULL;
32186 }
32187
32188
32189 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32190 PyObject *resultobj = 0;
32191 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 PyObject *swig_obj[1] ;
32195
32196 if (!args) SWIG_fail;
32197 swig_obj[0] = args;
32198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32199 if (!SWIG_IsOK(res1)) {
32200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32201 }
32202 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32203 {
32204 PyThreadState* __tstate = wxPyBeginAllowThreads();
32205 delete arg1;
32206
32207 wxPyEndAllowThreads(__tstate);
32208 if (PyErr_Occurred()) SWIG_fail;
32209 }
32210 resultobj = SWIG_Py_Void();
32211 return resultobj;
32212 fail:
32213 return NULL;
32214 }
32215
32216
32217 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32218 PyObject *resultobj = 0;
32219 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32220 int arg2 ;
32221 int arg3 ;
32222 int arg4 ;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 int val2 ;
32226 int ecode2 = 0 ;
32227 int val3 ;
32228 int ecode3 = 0 ;
32229 int val4 ;
32230 int ecode4 = 0 ;
32231 PyObject * obj0 = 0 ;
32232 PyObject * obj1 = 0 ;
32233 PyObject * obj2 = 0 ;
32234 PyObject * obj3 = 0 ;
32235 char * kwnames[] = {
32236 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32237 };
32238
32239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32243 }
32244 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32245 ecode2 = SWIG_AsVal_int(obj1, &val2);
32246 if (!SWIG_IsOK(ecode2)) {
32247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32248 }
32249 arg2 = static_cast< int >(val2);
32250 ecode3 = SWIG_AsVal_int(obj2, &val3);
32251 if (!SWIG_IsOK(ecode3)) {
32252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32253 }
32254 arg3 = static_cast< int >(val3);
32255 ecode4 = SWIG_AsVal_int(obj3, &val4);
32256 if (!SWIG_IsOK(ecode4)) {
32257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32258 }
32259 arg4 = static_cast< int >(val4);
32260 {
32261 PyThreadState* __tstate = wxPyBeginAllowThreads();
32262 (arg1)->Set(arg2,arg3,arg4);
32263 wxPyEndAllowThreads(__tstate);
32264 if (PyErr_Occurred()) SWIG_fail;
32265 }
32266 resultobj = SWIG_Py_Void();
32267 return resultobj;
32268 fail:
32269 return NULL;
32270 }
32271
32272
32273 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32274 PyObject *resultobj = 0;
32275 wxString *arg1 = 0 ;
32276 wxAcceleratorEntry *result = 0 ;
32277 bool temp1 = false ;
32278 PyObject * obj0 = 0 ;
32279 char * kwnames[] = {
32280 (char *) "str", NULL
32281 };
32282
32283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32284 {
32285 arg1 = wxString_in_helper(obj0);
32286 if (arg1 == NULL) SWIG_fail;
32287 temp1 = true;
32288 }
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32296 {
32297 if (temp1)
32298 delete arg1;
32299 }
32300 return resultobj;
32301 fail:
32302 {
32303 if (temp1)
32304 delete arg1;
32305 }
32306 return NULL;
32307 }
32308
32309
32310 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32311 PyObject *resultobj = 0;
32312 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32313 int result;
32314 void *argp1 = 0 ;
32315 int res1 = 0 ;
32316 PyObject *swig_obj[1] ;
32317
32318 if (!args) SWIG_fail;
32319 swig_obj[0] = args;
32320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32321 if (!SWIG_IsOK(res1)) {
32322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32323 }
32324 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 result = (int)(arg1)->GetFlags();
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 resultobj = SWIG_From_int(static_cast< int >(result));
32332 return resultobj;
32333 fail:
32334 return NULL;
32335 }
32336
32337
32338 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32339 PyObject *resultobj = 0;
32340 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32341 int result;
32342 void *argp1 = 0 ;
32343 int res1 = 0 ;
32344 PyObject *swig_obj[1] ;
32345
32346 if (!args) SWIG_fail;
32347 swig_obj[0] = args;
32348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32349 if (!SWIG_IsOK(res1)) {
32350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32351 }
32352 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 result = (int)(arg1)->GetKeyCode();
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 resultobj = SWIG_From_int(static_cast< int >(result));
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32367 PyObject *resultobj = 0;
32368 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32369 int result;
32370 void *argp1 = 0 ;
32371 int res1 = 0 ;
32372 PyObject *swig_obj[1] ;
32373
32374 if (!args) SWIG_fail;
32375 swig_obj[0] = args;
32376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32377 if (!SWIG_IsOK(res1)) {
32378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32379 }
32380 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 result = (int)(arg1)->GetCommand();
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 resultobj = SWIG_From_int(static_cast< int >(result));
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32397 bool result;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 PyObject *swig_obj[1] ;
32401
32402 if (!args) SWIG_fail;
32403 swig_obj[0] = args;
32404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32407 }
32408 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32417 }
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32425 PyObject *resultobj = 0;
32426 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32427 wxString result;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject *swig_obj[1] ;
32431
32432 if (!args) SWIG_fail;
32433 swig_obj[0] = args;
32434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32435 if (!SWIG_IsOK(res1)) {
32436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32437 }
32438 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 {
32446 #if wxUSE_UNICODE
32447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32448 #else
32449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32450 #endif
32451 }
32452 return resultobj;
32453 fail:
32454 return NULL;
32455 }
32456
32457
32458 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32459 PyObject *resultobj = 0;
32460 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32461 wxString *arg2 = 0 ;
32462 bool result;
32463 void *argp1 = 0 ;
32464 int res1 = 0 ;
32465 bool temp2 = false ;
32466 PyObject * obj0 = 0 ;
32467 PyObject * obj1 = 0 ;
32468 char * kwnames[] = {
32469 (char *) "self",(char *) "str", NULL
32470 };
32471
32472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32476 }
32477 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32478 {
32479 arg2 = wxString_in_helper(obj1);
32480 if (arg2 == NULL) SWIG_fail;
32481 temp2 = true;
32482 }
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32486 wxPyEndAllowThreads(__tstate);
32487 if (PyErr_Occurred()) SWIG_fail;
32488 }
32489 {
32490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32491 }
32492 {
32493 if (temp2)
32494 delete arg2;
32495 }
32496 return resultobj;
32497 fail:
32498 {
32499 if (temp2)
32500 delete arg2;
32501 }
32502 return NULL;
32503 }
32504
32505
32506 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32507 PyObject *obj;
32508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32509 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32510 return SWIG_Py_Void();
32511 }
32512
32513 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32514 return SWIG_Python_InitShadowInstance(args);
32515 }
32516
32517 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32518 PyObject *resultobj = 0;
32519 int arg1 ;
32520 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32521 wxAcceleratorTable *result = 0 ;
32522 PyObject * obj0 = 0 ;
32523 char * kwnames[] = {
32524 (char *) "n", NULL
32525 };
32526
32527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32528 {
32529 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32530 if (arg2) arg1 = PyList_Size(obj0);
32531 else arg1 = 0;
32532 }
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32549 void *argp1 = 0 ;
32550 int res1 = 0 ;
32551 PyObject *swig_obj[1] ;
32552
32553 if (!args) SWIG_fail;
32554 swig_obj[0] = args;
32555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32556 if (!SWIG_IsOK(res1)) {
32557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32558 }
32559 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 delete arg1;
32563
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_Py_Void();
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 PyObject *resultobj = 0;
32576 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32577 bool result;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject *swig_obj[1] ;
32581
32582 if (!args) SWIG_fail;
32583 swig_obj[0] = args;
32584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32585 if (!SWIG_IsOK(res1)) {
32586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32587 }
32588 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 {
32596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32597 }
32598 return resultobj;
32599 fail:
32600 return NULL;
32601 }
32602
32603
32604 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32605 PyObject *obj;
32606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32607 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32608 return SWIG_Py_Void();
32609 }
32610
32611 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32612 return SWIG_Python_InitShadowInstance(args);
32613 }
32614
32615 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32616 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32617 return 1;
32618 }
32619
32620
32621 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32622 PyObject *pyobj = 0;
32623
32624 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32625 return pyobj;
32626 }
32627
32628
32629 SWIGINTERN int PanelNameStr_set(PyObject *) {
32630 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32631 return 1;
32632 }
32633
32634
32635 SWIGINTERN PyObject *PanelNameStr_get(void) {
32636 PyObject *pyobj = 0;
32637
32638 {
32639 #if wxUSE_UNICODE
32640 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32641 #else
32642 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32643 #endif
32644 }
32645 return pyobj;
32646 }
32647
32648
32649 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32650 PyObject *resultobj = 0;
32651 wxVisualAttributes *result = 0 ;
32652
32653 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32654 {
32655 PyThreadState* __tstate = wxPyBeginAllowThreads();
32656 result = (wxVisualAttributes *)new_wxVisualAttributes();
32657 wxPyEndAllowThreads(__tstate);
32658 if (PyErr_Occurred()) SWIG_fail;
32659 }
32660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32661 return resultobj;
32662 fail:
32663 return NULL;
32664 }
32665
32666
32667 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32668 PyObject *resultobj = 0;
32669 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 PyObject *swig_obj[1] ;
32673
32674 if (!args) SWIG_fail;
32675 swig_obj[0] = args;
32676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32679 }
32680 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 delete_wxVisualAttributes(arg1);
32684
32685 wxPyEndAllowThreads(__tstate);
32686 if (PyErr_Occurred()) SWIG_fail;
32687 }
32688 resultobj = SWIG_Py_Void();
32689 return resultobj;
32690 fail:
32691 return NULL;
32692 }
32693
32694
32695 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32696 PyObject *resultobj = 0;
32697 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32698 wxFont *arg2 = (wxFont *) 0 ;
32699 void *argp1 = 0 ;
32700 int res1 = 0 ;
32701 void *argp2 = 0 ;
32702 int res2 = 0 ;
32703 PyObject *swig_obj[2] ;
32704
32705 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32707 if (!SWIG_IsOK(res1)) {
32708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32709 }
32710 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32711 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32712 if (!SWIG_IsOK(res2)) {
32713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32714 }
32715 arg2 = reinterpret_cast< wxFont * >(argp2);
32716 if (arg1) (arg1)->font = *arg2;
32717
32718 resultobj = SWIG_Py_Void();
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32726 PyObject *resultobj = 0;
32727 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32728 wxFont *result = 0 ;
32729 void *argp1 = 0 ;
32730 int res1 = 0 ;
32731 PyObject *swig_obj[1] ;
32732
32733 if (!args) SWIG_fail;
32734 swig_obj[0] = args;
32735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32736 if (!SWIG_IsOK(res1)) {
32737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32738 }
32739 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32740 result = (wxFont *)& ((arg1)->font);
32741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32742 return resultobj;
32743 fail:
32744 return NULL;
32745 }
32746
32747
32748 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32749 PyObject *resultobj = 0;
32750 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32751 wxColour *arg2 = (wxColour *) 0 ;
32752 void *argp1 = 0 ;
32753 int res1 = 0 ;
32754 void *argp2 = 0 ;
32755 int res2 = 0 ;
32756 PyObject *swig_obj[2] ;
32757
32758 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32760 if (!SWIG_IsOK(res1)) {
32761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32762 }
32763 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32764 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32765 if (!SWIG_IsOK(res2)) {
32766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32767 }
32768 arg2 = reinterpret_cast< wxColour * >(argp2);
32769 if (arg1) (arg1)->colFg = *arg2;
32770
32771 resultobj = SWIG_Py_Void();
32772 return resultobj;
32773 fail:
32774 return NULL;
32775 }
32776
32777
32778 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32779 PyObject *resultobj = 0;
32780 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32781 wxColour *result = 0 ;
32782 void *argp1 = 0 ;
32783 int res1 = 0 ;
32784 PyObject *swig_obj[1] ;
32785
32786 if (!args) SWIG_fail;
32787 swig_obj[0] = args;
32788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32789 if (!SWIG_IsOK(res1)) {
32790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32791 }
32792 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32793 result = (wxColour *)& ((arg1)->colFg);
32794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32795 return resultobj;
32796 fail:
32797 return NULL;
32798 }
32799
32800
32801 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32802 PyObject *resultobj = 0;
32803 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32804 wxColour *arg2 = (wxColour *) 0 ;
32805 void *argp1 = 0 ;
32806 int res1 = 0 ;
32807 void *argp2 = 0 ;
32808 int res2 = 0 ;
32809 PyObject *swig_obj[2] ;
32810
32811 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32813 if (!SWIG_IsOK(res1)) {
32814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32815 }
32816 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32817 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32818 if (!SWIG_IsOK(res2)) {
32819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32820 }
32821 arg2 = reinterpret_cast< wxColour * >(argp2);
32822 if (arg1) (arg1)->colBg = *arg2;
32823
32824 resultobj = SWIG_Py_Void();
32825 return resultobj;
32826 fail:
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32832 PyObject *resultobj = 0;
32833 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32834 wxColour *result = 0 ;
32835 void *argp1 = 0 ;
32836 int res1 = 0 ;
32837 PyObject *swig_obj[1] ;
32838
32839 if (!args) SWIG_fail;
32840 swig_obj[0] = args;
32841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32842 if (!SWIG_IsOK(res1)) {
32843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32844 }
32845 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32846 result = (wxColour *)& ((arg1)->colBg);
32847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32855 PyObject *obj;
32856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32857 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32858 return SWIG_Py_Void();
32859 }
32860
32861 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32862 return SWIG_Python_InitShadowInstance(args);
32863 }
32864
32865 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32866 PyObject *resultobj = 0;
32867 wxWindow *arg1 = (wxWindow *) 0 ;
32868 int arg2 = (int) (int)-1 ;
32869 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32870 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32871 wxSize const &arg4_defvalue = wxDefaultSize ;
32872 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32873 long arg5 = (long) 0 ;
32874 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32875 wxString *arg6 = (wxString *) &arg6_defvalue ;
32876 wxWindow *result = 0 ;
32877 void *argp1 = 0 ;
32878 int res1 = 0 ;
32879 int val2 ;
32880 int ecode2 = 0 ;
32881 wxPoint temp3 ;
32882 wxSize temp4 ;
32883 long val5 ;
32884 int ecode5 = 0 ;
32885 bool temp6 = false ;
32886 PyObject * obj0 = 0 ;
32887 PyObject * obj1 = 0 ;
32888 PyObject * obj2 = 0 ;
32889 PyObject * obj3 = 0 ;
32890 PyObject * obj4 = 0 ;
32891 PyObject * obj5 = 0 ;
32892 char * kwnames[] = {
32893 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32894 };
32895
32896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32898 if (!SWIG_IsOK(res1)) {
32899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32900 }
32901 arg1 = reinterpret_cast< wxWindow * >(argp1);
32902 if (obj1) {
32903 ecode2 = SWIG_AsVal_int(obj1, &val2);
32904 if (!SWIG_IsOK(ecode2)) {
32905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32906 }
32907 arg2 = static_cast< int >(val2);
32908 }
32909 if (obj2) {
32910 {
32911 arg3 = &temp3;
32912 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32913 }
32914 }
32915 if (obj3) {
32916 {
32917 arg4 = &temp4;
32918 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32919 }
32920 }
32921 if (obj4) {
32922 ecode5 = SWIG_AsVal_long(obj4, &val5);
32923 if (!SWIG_IsOK(ecode5)) {
32924 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32925 }
32926 arg5 = static_cast< long >(val5);
32927 }
32928 if (obj5) {
32929 {
32930 arg6 = wxString_in_helper(obj5);
32931 if (arg6 == NULL) SWIG_fail;
32932 temp6 = true;
32933 }
32934 }
32935 {
32936 if (!wxPyCheckForApp()) SWIG_fail;
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32943 {
32944 if (temp6)
32945 delete arg6;
32946 }
32947 return resultobj;
32948 fail:
32949 {
32950 if (temp6)
32951 delete arg6;
32952 }
32953 return NULL;
32954 }
32955
32956
32957 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32958 PyObject *resultobj = 0;
32959 wxWindow *result = 0 ;
32960
32961 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32962 {
32963 if (!wxPyCheckForApp()) SWIG_fail;
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 result = (wxWindow *)new wxWindow();
32966 wxPyEndAllowThreads(__tstate);
32967 if (PyErr_Occurred()) SWIG_fail;
32968 }
32969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32970 return resultobj;
32971 fail:
32972 return NULL;
32973 }
32974
32975
32976 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32977 PyObject *resultobj = 0;
32978 wxWindow *arg1 = (wxWindow *) 0 ;
32979 wxWindow *arg2 = (wxWindow *) 0 ;
32980 int arg3 = (int) (int)-1 ;
32981 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32982 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32983 wxSize const &arg5_defvalue = wxDefaultSize ;
32984 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32985 long arg6 = (long) 0 ;
32986 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32987 wxString *arg7 = (wxString *) &arg7_defvalue ;
32988 bool result;
32989 void *argp1 = 0 ;
32990 int res1 = 0 ;
32991 void *argp2 = 0 ;
32992 int res2 = 0 ;
32993 int val3 ;
32994 int ecode3 = 0 ;
32995 wxPoint temp4 ;
32996 wxSize temp5 ;
32997 long val6 ;
32998 int ecode6 = 0 ;
32999 bool temp7 = false ;
33000 PyObject * obj0 = 0 ;
33001 PyObject * obj1 = 0 ;
33002 PyObject * obj2 = 0 ;
33003 PyObject * obj3 = 0 ;
33004 PyObject * obj4 = 0 ;
33005 PyObject * obj5 = 0 ;
33006 PyObject * obj6 = 0 ;
33007 char * kwnames[] = {
33008 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33009 };
33010
33011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33013 if (!SWIG_IsOK(res1)) {
33014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33015 }
33016 arg1 = reinterpret_cast< wxWindow * >(argp1);
33017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33018 if (!SWIG_IsOK(res2)) {
33019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33020 }
33021 arg2 = reinterpret_cast< wxWindow * >(argp2);
33022 if (obj2) {
33023 ecode3 = SWIG_AsVal_int(obj2, &val3);
33024 if (!SWIG_IsOK(ecode3)) {
33025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33026 }
33027 arg3 = static_cast< int >(val3);
33028 }
33029 if (obj3) {
33030 {
33031 arg4 = &temp4;
33032 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33033 }
33034 }
33035 if (obj4) {
33036 {
33037 arg5 = &temp5;
33038 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33039 }
33040 }
33041 if (obj5) {
33042 ecode6 = SWIG_AsVal_long(obj5, &val6);
33043 if (!SWIG_IsOK(ecode6)) {
33044 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33045 }
33046 arg6 = static_cast< long >(val6);
33047 }
33048 if (obj6) {
33049 {
33050 arg7 = wxString_in_helper(obj6);
33051 if (arg7 == NULL) SWIG_fail;
33052 temp7 = true;
33053 }
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 {
33062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33063 }
33064 {
33065 if (temp7)
33066 delete arg7;
33067 }
33068 return resultobj;
33069 fail:
33070 {
33071 if (temp7)
33072 delete arg7;
33073 }
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33079 PyObject *resultobj = 0;
33080 wxWindow *arg1 = (wxWindow *) 0 ;
33081 bool arg2 = (bool) false ;
33082 bool result;
33083 void *argp1 = 0 ;
33084 int res1 = 0 ;
33085 bool val2 ;
33086 int ecode2 = 0 ;
33087 PyObject * obj0 = 0 ;
33088 PyObject * obj1 = 0 ;
33089 char * kwnames[] = {
33090 (char *) "self",(char *) "force", NULL
33091 };
33092
33093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33095 if (!SWIG_IsOK(res1)) {
33096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33097 }
33098 arg1 = reinterpret_cast< wxWindow * >(argp1);
33099 if (obj1) {
33100 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33101 if (!SWIG_IsOK(ecode2)) {
33102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33103 }
33104 arg2 = static_cast< bool >(val2);
33105 }
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (bool)(arg1)->Close(arg2);
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 {
33113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33114 }
33115 return resultobj;
33116 fail:
33117 return NULL;
33118 }
33119
33120
33121 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33122 PyObject *resultobj = 0;
33123 wxWindow *arg1 = (wxWindow *) 0 ;
33124 bool result;
33125 void *argp1 = 0 ;
33126 int res1 = 0 ;
33127 PyObject *swig_obj[1] ;
33128
33129 if (!args) SWIG_fail;
33130 swig_obj[0] = args;
33131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33132 if (!SWIG_IsOK(res1)) {
33133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33134 }
33135 arg1 = reinterpret_cast< wxWindow * >(argp1);
33136 {
33137 PyThreadState* __tstate = wxPyBeginAllowThreads();
33138 result = (bool)(arg1)->Destroy();
33139 wxPyEndAllowThreads(__tstate);
33140 if (PyErr_Occurred()) SWIG_fail;
33141 }
33142 {
33143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33144 }
33145 return resultobj;
33146 fail:
33147 return NULL;
33148 }
33149
33150
33151 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33152 PyObject *resultobj = 0;
33153 wxWindow *arg1 = (wxWindow *) 0 ;
33154 bool result;
33155 void *argp1 = 0 ;
33156 int res1 = 0 ;
33157 PyObject *swig_obj[1] ;
33158
33159 if (!args) SWIG_fail;
33160 swig_obj[0] = args;
33161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 {
33167 PyThreadState* __tstate = wxPyBeginAllowThreads();
33168 result = (bool)(arg1)->DestroyChildren();
33169 wxPyEndAllowThreads(__tstate);
33170 if (PyErr_Occurred()) SWIG_fail;
33171 }
33172 {
33173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33174 }
33175 return resultobj;
33176 fail:
33177 return NULL;
33178 }
33179
33180
33181 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33182 PyObject *resultobj = 0;
33183 wxWindow *arg1 = (wxWindow *) 0 ;
33184 bool result;
33185 void *argp1 = 0 ;
33186 int res1 = 0 ;
33187 PyObject *swig_obj[1] ;
33188
33189 if (!args) SWIG_fail;
33190 swig_obj[0] = args;
33191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33192 if (!SWIG_IsOK(res1)) {
33193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33194 }
33195 arg1 = reinterpret_cast< wxWindow * >(argp1);
33196 {
33197 PyThreadState* __tstate = wxPyBeginAllowThreads();
33198 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33199 wxPyEndAllowThreads(__tstate);
33200 if (PyErr_Occurred()) SWIG_fail;
33201 }
33202 {
33203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33204 }
33205 return resultobj;
33206 fail:
33207 return NULL;
33208 }
33209
33210
33211 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33212 PyObject *resultobj = 0;
33213 wxWindow *arg1 = (wxWindow *) 0 ;
33214 wxString *arg2 = 0 ;
33215 void *argp1 = 0 ;
33216 int res1 = 0 ;
33217 bool temp2 = false ;
33218 PyObject * obj0 = 0 ;
33219 PyObject * obj1 = 0 ;
33220 char * kwnames[] = {
33221 (char *) "self",(char *) "label", NULL
33222 };
33223
33224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33226 if (!SWIG_IsOK(res1)) {
33227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33228 }
33229 arg1 = reinterpret_cast< wxWindow * >(argp1);
33230 {
33231 arg2 = wxString_in_helper(obj1);
33232 if (arg2 == NULL) SWIG_fail;
33233 temp2 = true;
33234 }
33235 {
33236 PyThreadState* __tstate = wxPyBeginAllowThreads();
33237 (arg1)->SetLabel((wxString const &)*arg2);
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 resultobj = SWIG_Py_Void();
33242 {
33243 if (temp2)
33244 delete arg2;
33245 }
33246 return resultobj;
33247 fail:
33248 {
33249 if (temp2)
33250 delete arg2;
33251 }
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33257 PyObject *resultobj = 0;
33258 wxWindow *arg1 = (wxWindow *) 0 ;
33259 wxString result;
33260 void *argp1 = 0 ;
33261 int res1 = 0 ;
33262 PyObject *swig_obj[1] ;
33263
33264 if (!args) SWIG_fail;
33265 swig_obj[0] = args;
33266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33267 if (!SWIG_IsOK(res1)) {
33268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33269 }
33270 arg1 = reinterpret_cast< wxWindow * >(argp1);
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 result = ((wxWindow const *)arg1)->GetLabel();
33274 wxPyEndAllowThreads(__tstate);
33275 if (PyErr_Occurred()) SWIG_fail;
33276 }
33277 {
33278 #if wxUSE_UNICODE
33279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33280 #else
33281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33282 #endif
33283 }
33284 return resultobj;
33285 fail:
33286 return NULL;
33287 }
33288
33289
33290 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33291 PyObject *resultobj = 0;
33292 wxWindow *arg1 = (wxWindow *) 0 ;
33293 wxString *arg2 = 0 ;
33294 void *argp1 = 0 ;
33295 int res1 = 0 ;
33296 bool temp2 = false ;
33297 PyObject * obj0 = 0 ;
33298 PyObject * obj1 = 0 ;
33299 char * kwnames[] = {
33300 (char *) "self",(char *) "name", NULL
33301 };
33302
33303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33305 if (!SWIG_IsOK(res1)) {
33306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33307 }
33308 arg1 = reinterpret_cast< wxWindow * >(argp1);
33309 {
33310 arg2 = wxString_in_helper(obj1);
33311 if (arg2 == NULL) SWIG_fail;
33312 temp2 = true;
33313 }
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 (arg1)->SetName((wxString const &)*arg2);
33317 wxPyEndAllowThreads(__tstate);
33318 if (PyErr_Occurred()) SWIG_fail;
33319 }
33320 resultobj = SWIG_Py_Void();
33321 {
33322 if (temp2)
33323 delete arg2;
33324 }
33325 return resultobj;
33326 fail:
33327 {
33328 if (temp2)
33329 delete arg2;
33330 }
33331 return NULL;
33332 }
33333
33334
33335 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33336 PyObject *resultobj = 0;
33337 wxWindow *arg1 = (wxWindow *) 0 ;
33338 wxString result;
33339 void *argp1 = 0 ;
33340 int res1 = 0 ;
33341 PyObject *swig_obj[1] ;
33342
33343 if (!args) SWIG_fail;
33344 swig_obj[0] = args;
33345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33346 if (!SWIG_IsOK(res1)) {
33347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33348 }
33349 arg1 = reinterpret_cast< wxWindow * >(argp1);
33350 {
33351 PyThreadState* __tstate = wxPyBeginAllowThreads();
33352 result = ((wxWindow const *)arg1)->GetName();
33353 wxPyEndAllowThreads(__tstate);
33354 if (PyErr_Occurred()) SWIG_fail;
33355 }
33356 {
33357 #if wxUSE_UNICODE
33358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33359 #else
33360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33361 #endif
33362 }
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj = 0;
33371 wxWindow *arg1 = (wxWindow *) 0 ;
33372 wxWindowVariant arg2 ;
33373 void *argp1 = 0 ;
33374 int res1 = 0 ;
33375 int val2 ;
33376 int ecode2 = 0 ;
33377 PyObject * obj0 = 0 ;
33378 PyObject * obj1 = 0 ;
33379 char * kwnames[] = {
33380 (char *) "self",(char *) "variant", NULL
33381 };
33382
33383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33385 if (!SWIG_IsOK(res1)) {
33386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33387 }
33388 arg1 = reinterpret_cast< wxWindow * >(argp1);
33389 ecode2 = SWIG_AsVal_int(obj1, &val2);
33390 if (!SWIG_IsOK(ecode2)) {
33391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33392 }
33393 arg2 = static_cast< wxWindowVariant >(val2);
33394 {
33395 PyThreadState* __tstate = wxPyBeginAllowThreads();
33396 (arg1)->SetWindowVariant(arg2);
33397 wxPyEndAllowThreads(__tstate);
33398 if (PyErr_Occurred()) SWIG_fail;
33399 }
33400 resultobj = SWIG_Py_Void();
33401 return resultobj;
33402 fail:
33403 return NULL;
33404 }
33405
33406
33407 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33408 PyObject *resultobj = 0;
33409 wxWindow *arg1 = (wxWindow *) 0 ;
33410 wxWindowVariant result;
33411 void *argp1 = 0 ;
33412 int res1 = 0 ;
33413 PyObject *swig_obj[1] ;
33414
33415 if (!args) SWIG_fail;
33416 swig_obj[0] = args;
33417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33418 if (!SWIG_IsOK(res1)) {
33419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33420 }
33421 arg1 = reinterpret_cast< wxWindow * >(argp1);
33422 {
33423 PyThreadState* __tstate = wxPyBeginAllowThreads();
33424 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33425 wxPyEndAllowThreads(__tstate);
33426 if (PyErr_Occurred()) SWIG_fail;
33427 }
33428 resultobj = SWIG_From_int(static_cast< int >(result));
33429 return resultobj;
33430 fail:
33431 return NULL;
33432 }
33433
33434
33435 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33436 PyObject *resultobj = 0;
33437 wxWindow *arg1 = (wxWindow *) 0 ;
33438 int arg2 ;
33439 void *argp1 = 0 ;
33440 int res1 = 0 ;
33441 int val2 ;
33442 int ecode2 = 0 ;
33443 PyObject * obj0 = 0 ;
33444 PyObject * obj1 = 0 ;
33445 char * kwnames[] = {
33446 (char *) "self",(char *) "winid", NULL
33447 };
33448
33449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33453 }
33454 arg1 = reinterpret_cast< wxWindow * >(argp1);
33455 ecode2 = SWIG_AsVal_int(obj1, &val2);
33456 if (!SWIG_IsOK(ecode2)) {
33457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33458 }
33459 arg2 = static_cast< int >(val2);
33460 {
33461 PyThreadState* __tstate = wxPyBeginAllowThreads();
33462 (arg1)->SetId(arg2);
33463 wxPyEndAllowThreads(__tstate);
33464 if (PyErr_Occurred()) SWIG_fail;
33465 }
33466 resultobj = SWIG_Py_Void();
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33474 PyObject *resultobj = 0;
33475 wxWindow *arg1 = (wxWindow *) 0 ;
33476 int result;
33477 void *argp1 = 0 ;
33478 int res1 = 0 ;
33479 PyObject *swig_obj[1] ;
33480
33481 if (!args) SWIG_fail;
33482 swig_obj[0] = args;
33483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33484 if (!SWIG_IsOK(res1)) {
33485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33486 }
33487 arg1 = reinterpret_cast< wxWindow * >(argp1);
33488 {
33489 PyThreadState* __tstate = wxPyBeginAllowThreads();
33490 result = (int)((wxWindow const *)arg1)->GetId();
33491 wxPyEndAllowThreads(__tstate);
33492 if (PyErr_Occurred()) SWIG_fail;
33493 }
33494 resultobj = SWIG_From_int(static_cast< int >(result));
33495 return resultobj;
33496 fail:
33497 return NULL;
33498 }
33499
33500
33501 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33502 PyObject *resultobj = 0;
33503 int result;
33504
33505 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33506 {
33507 PyThreadState* __tstate = wxPyBeginAllowThreads();
33508 result = (int)wxWindow::NewControlId();
33509 wxPyEndAllowThreads(__tstate);
33510 if (PyErr_Occurred()) SWIG_fail;
33511 }
33512 resultobj = SWIG_From_int(static_cast< int >(result));
33513 return resultobj;
33514 fail:
33515 return NULL;
33516 }
33517
33518
33519 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33520 PyObject *resultobj = 0;
33521 int arg1 ;
33522 int result;
33523 int val1 ;
33524 int ecode1 = 0 ;
33525 PyObject * obj0 = 0 ;
33526 char * kwnames[] = {
33527 (char *) "winid", NULL
33528 };
33529
33530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33531 ecode1 = SWIG_AsVal_int(obj0, &val1);
33532 if (!SWIG_IsOK(ecode1)) {
33533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33534 }
33535 arg1 = static_cast< int >(val1);
33536 {
33537 PyThreadState* __tstate = wxPyBeginAllowThreads();
33538 result = (int)wxWindow::NextControlId(arg1);
33539 wxPyEndAllowThreads(__tstate);
33540 if (PyErr_Occurred()) SWIG_fail;
33541 }
33542 resultobj = SWIG_From_int(static_cast< int >(result));
33543 return resultobj;
33544 fail:
33545 return NULL;
33546 }
33547
33548
33549 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33550 PyObject *resultobj = 0;
33551 int arg1 ;
33552 int result;
33553 int val1 ;
33554 int ecode1 = 0 ;
33555 PyObject * obj0 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "winid", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33561 ecode1 = SWIG_AsVal_int(obj0, &val1);
33562 if (!SWIG_IsOK(ecode1)) {
33563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33564 }
33565 arg1 = static_cast< int >(val1);
33566 {
33567 PyThreadState* __tstate = wxPyBeginAllowThreads();
33568 result = (int)wxWindow::PrevControlId(arg1);
33569 wxPyEndAllowThreads(__tstate);
33570 if (PyErr_Occurred()) SWIG_fail;
33571 }
33572 resultobj = SWIG_From_int(static_cast< int >(result));
33573 return resultobj;
33574 fail:
33575 return NULL;
33576 }
33577
33578
33579 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33580 PyObject *resultobj = 0;
33581 wxWindow *arg1 = (wxWindow *) 0 ;
33582 wxLayoutDirection result;
33583 void *argp1 = 0 ;
33584 int res1 = 0 ;
33585 PyObject *swig_obj[1] ;
33586
33587 if (!args) SWIG_fail;
33588 swig_obj[0] = args;
33589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33590 if (!SWIG_IsOK(res1)) {
33591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33592 }
33593 arg1 = reinterpret_cast< wxWindow * >(argp1);
33594 {
33595 PyThreadState* __tstate = wxPyBeginAllowThreads();
33596 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33597 wxPyEndAllowThreads(__tstate);
33598 if (PyErr_Occurred()) SWIG_fail;
33599 }
33600 resultobj = SWIG_From_int(static_cast< int >(result));
33601 return resultobj;
33602 fail:
33603 return NULL;
33604 }
33605
33606
33607 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33608 PyObject *resultobj = 0;
33609 wxWindow *arg1 = (wxWindow *) 0 ;
33610 wxLayoutDirection arg2 ;
33611 void *argp1 = 0 ;
33612 int res1 = 0 ;
33613 int val2 ;
33614 int ecode2 = 0 ;
33615 PyObject * obj0 = 0 ;
33616 PyObject * obj1 = 0 ;
33617 char * kwnames[] = {
33618 (char *) "self",(char *) "dir", NULL
33619 };
33620
33621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33623 if (!SWIG_IsOK(res1)) {
33624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33625 }
33626 arg1 = reinterpret_cast< wxWindow * >(argp1);
33627 ecode2 = SWIG_AsVal_int(obj1, &val2);
33628 if (!SWIG_IsOK(ecode2)) {
33629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33630 }
33631 arg2 = static_cast< wxLayoutDirection >(val2);
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 (arg1)->SetLayoutDirection(arg2);
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 resultobj = SWIG_Py_Void();
33639 return resultobj;
33640 fail:
33641 return NULL;
33642 }
33643
33644
33645 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33646 PyObject *resultobj = 0;
33647 wxWindow *arg1 = (wxWindow *) 0 ;
33648 int arg2 ;
33649 int arg3 ;
33650 int arg4 ;
33651 int result;
33652 void *argp1 = 0 ;
33653 int res1 = 0 ;
33654 int val2 ;
33655 int ecode2 = 0 ;
33656 int val3 ;
33657 int ecode3 = 0 ;
33658 int val4 ;
33659 int ecode4 = 0 ;
33660 PyObject * obj0 = 0 ;
33661 PyObject * obj1 = 0 ;
33662 PyObject * obj2 = 0 ;
33663 PyObject * obj3 = 0 ;
33664 char * kwnames[] = {
33665 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33666 };
33667
33668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33670 if (!SWIG_IsOK(res1)) {
33671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33672 }
33673 arg1 = reinterpret_cast< wxWindow * >(argp1);
33674 ecode2 = SWIG_AsVal_int(obj1, &val2);
33675 if (!SWIG_IsOK(ecode2)) {
33676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33677 }
33678 arg2 = static_cast< int >(val2);
33679 ecode3 = SWIG_AsVal_int(obj2, &val3);
33680 if (!SWIG_IsOK(ecode3)) {
33681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33682 }
33683 arg3 = static_cast< int >(val3);
33684 ecode4 = SWIG_AsVal_int(obj3, &val4);
33685 if (!SWIG_IsOK(ecode4)) {
33686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33687 }
33688 arg4 = static_cast< int >(val4);
33689 {
33690 PyThreadState* __tstate = wxPyBeginAllowThreads();
33691 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 resultobj = SWIG_From_int(static_cast< int >(result));
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33703 PyObject *resultobj = 0;
33704 wxWindow *arg1 = (wxWindow *) 0 ;
33705 wxSize *arg2 = 0 ;
33706 void *argp1 = 0 ;
33707 int res1 = 0 ;
33708 wxSize temp2 ;
33709 PyObject * obj0 = 0 ;
33710 PyObject * obj1 = 0 ;
33711 char * kwnames[] = {
33712 (char *) "self",(char *) "size", NULL
33713 };
33714
33715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33717 if (!SWIG_IsOK(res1)) {
33718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33719 }
33720 arg1 = reinterpret_cast< wxWindow * >(argp1);
33721 {
33722 arg2 = &temp2;
33723 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33724 }
33725 {
33726 PyThreadState* __tstate = wxPyBeginAllowThreads();
33727 (arg1)->SetSize((wxSize const &)*arg2);
33728 wxPyEndAllowThreads(__tstate);
33729 if (PyErr_Occurred()) SWIG_fail;
33730 }
33731 resultobj = SWIG_Py_Void();
33732 return resultobj;
33733 fail:
33734 return NULL;
33735 }
33736
33737
33738 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33739 PyObject *resultobj = 0;
33740 wxWindow *arg1 = (wxWindow *) 0 ;
33741 int arg2 ;
33742 int arg3 ;
33743 int arg4 ;
33744 int arg5 ;
33745 int arg6 = (int) wxSIZE_AUTO ;
33746 void *argp1 = 0 ;
33747 int res1 = 0 ;
33748 int val2 ;
33749 int ecode2 = 0 ;
33750 int val3 ;
33751 int ecode3 = 0 ;
33752 int val4 ;
33753 int ecode4 = 0 ;
33754 int val5 ;
33755 int ecode5 = 0 ;
33756 int val6 ;
33757 int ecode6 = 0 ;
33758 PyObject * obj0 = 0 ;
33759 PyObject * obj1 = 0 ;
33760 PyObject * obj2 = 0 ;
33761 PyObject * obj3 = 0 ;
33762 PyObject * obj4 = 0 ;
33763 PyObject * obj5 = 0 ;
33764 char * kwnames[] = {
33765 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33766 };
33767
33768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33770 if (!SWIG_IsOK(res1)) {
33771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33772 }
33773 arg1 = reinterpret_cast< wxWindow * >(argp1);
33774 ecode2 = SWIG_AsVal_int(obj1, &val2);
33775 if (!SWIG_IsOK(ecode2)) {
33776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33777 }
33778 arg2 = static_cast< int >(val2);
33779 ecode3 = SWIG_AsVal_int(obj2, &val3);
33780 if (!SWIG_IsOK(ecode3)) {
33781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33782 }
33783 arg3 = static_cast< int >(val3);
33784 ecode4 = SWIG_AsVal_int(obj3, &val4);
33785 if (!SWIG_IsOK(ecode4)) {
33786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33787 }
33788 arg4 = static_cast< int >(val4);
33789 ecode5 = SWIG_AsVal_int(obj4, &val5);
33790 if (!SWIG_IsOK(ecode5)) {
33791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33792 }
33793 arg5 = static_cast< int >(val5);
33794 if (obj5) {
33795 ecode6 = SWIG_AsVal_int(obj5, &val6);
33796 if (!SWIG_IsOK(ecode6)) {
33797 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33798 }
33799 arg6 = static_cast< int >(val6);
33800 }
33801 {
33802 PyThreadState* __tstate = wxPyBeginAllowThreads();
33803 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33804 wxPyEndAllowThreads(__tstate);
33805 if (PyErr_Occurred()) SWIG_fail;
33806 }
33807 resultobj = SWIG_Py_Void();
33808 return resultobj;
33809 fail:
33810 return NULL;
33811 }
33812
33813
33814 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33815 PyObject *resultobj = 0;
33816 wxWindow *arg1 = (wxWindow *) 0 ;
33817 wxRect *arg2 = 0 ;
33818 int arg3 = (int) wxSIZE_AUTO ;
33819 void *argp1 = 0 ;
33820 int res1 = 0 ;
33821 wxRect temp2 ;
33822 int val3 ;
33823 int ecode3 = 0 ;
33824 PyObject * obj0 = 0 ;
33825 PyObject * obj1 = 0 ;
33826 PyObject * obj2 = 0 ;
33827 char * kwnames[] = {
33828 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33829 };
33830
33831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33833 if (!SWIG_IsOK(res1)) {
33834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33835 }
33836 arg1 = reinterpret_cast< wxWindow * >(argp1);
33837 {
33838 arg2 = &temp2;
33839 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33840 }
33841 if (obj2) {
33842 ecode3 = SWIG_AsVal_int(obj2, &val3);
33843 if (!SWIG_IsOK(ecode3)) {
33844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33845 }
33846 arg3 = static_cast< int >(val3);
33847 }
33848 {
33849 PyThreadState* __tstate = wxPyBeginAllowThreads();
33850 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 resultobj = SWIG_Py_Void();
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33862 PyObject *resultobj = 0;
33863 wxWindow *arg1 = (wxWindow *) 0 ;
33864 int arg2 ;
33865 int arg3 ;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 int val2 ;
33869 int ecode2 = 0 ;
33870 int val3 ;
33871 int ecode3 = 0 ;
33872 PyObject * obj0 = 0 ;
33873 PyObject * obj1 = 0 ;
33874 PyObject * obj2 = 0 ;
33875 char * kwnames[] = {
33876 (char *) "self",(char *) "width",(char *) "height", NULL
33877 };
33878
33879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33881 if (!SWIG_IsOK(res1)) {
33882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33883 }
33884 arg1 = reinterpret_cast< wxWindow * >(argp1);
33885 ecode2 = SWIG_AsVal_int(obj1, &val2);
33886 if (!SWIG_IsOK(ecode2)) {
33887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33888 }
33889 arg2 = static_cast< int >(val2);
33890 ecode3 = SWIG_AsVal_int(obj2, &val3);
33891 if (!SWIG_IsOK(ecode3)) {
33892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33893 }
33894 arg3 = static_cast< int >(val3);
33895 {
33896 PyThreadState* __tstate = wxPyBeginAllowThreads();
33897 (arg1)->SetSize(arg2,arg3);
33898 wxPyEndAllowThreads(__tstate);
33899 if (PyErr_Occurred()) SWIG_fail;
33900 }
33901 resultobj = SWIG_Py_Void();
33902 return resultobj;
33903 fail:
33904 return NULL;
33905 }
33906
33907
33908 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33909 PyObject *resultobj = 0;
33910 wxWindow *arg1 = (wxWindow *) 0 ;
33911 wxPoint *arg2 = 0 ;
33912 int arg3 = (int) wxSIZE_USE_EXISTING ;
33913 void *argp1 = 0 ;
33914 int res1 = 0 ;
33915 wxPoint temp2 ;
33916 int val3 ;
33917 int ecode3 = 0 ;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 PyObject * obj2 = 0 ;
33921 char * kwnames[] = {
33922 (char *) "self",(char *) "pt",(char *) "flags", NULL
33923 };
33924
33925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33927 if (!SWIG_IsOK(res1)) {
33928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33929 }
33930 arg1 = reinterpret_cast< wxWindow * >(argp1);
33931 {
33932 arg2 = &temp2;
33933 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33934 }
33935 if (obj2) {
33936 ecode3 = SWIG_AsVal_int(obj2, &val3);
33937 if (!SWIG_IsOK(ecode3)) {
33938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33939 }
33940 arg3 = static_cast< int >(val3);
33941 }
33942 {
33943 PyThreadState* __tstate = wxPyBeginAllowThreads();
33944 (arg1)->Move((wxPoint const &)*arg2,arg3);
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 resultobj = SWIG_Py_Void();
33949 return resultobj;
33950 fail:
33951 return NULL;
33952 }
33953
33954
33955 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33956 PyObject *resultobj = 0;
33957 wxWindow *arg1 = (wxWindow *) 0 ;
33958 int arg2 ;
33959 int arg3 ;
33960 int arg4 = (int) wxSIZE_USE_EXISTING ;
33961 void *argp1 = 0 ;
33962 int res1 = 0 ;
33963 int val2 ;
33964 int ecode2 = 0 ;
33965 int val3 ;
33966 int ecode3 = 0 ;
33967 int val4 ;
33968 int ecode4 = 0 ;
33969 PyObject * obj0 = 0 ;
33970 PyObject * obj1 = 0 ;
33971 PyObject * obj2 = 0 ;
33972 PyObject * obj3 = 0 ;
33973 char * kwnames[] = {
33974 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33975 };
33976
33977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33979 if (!SWIG_IsOK(res1)) {
33980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33981 }
33982 arg1 = reinterpret_cast< wxWindow * >(argp1);
33983 ecode2 = SWIG_AsVal_int(obj1, &val2);
33984 if (!SWIG_IsOK(ecode2)) {
33985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33986 }
33987 arg2 = static_cast< int >(val2);
33988 ecode3 = SWIG_AsVal_int(obj2, &val3);
33989 if (!SWIG_IsOK(ecode3)) {
33990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33991 }
33992 arg3 = static_cast< int >(val3);
33993 if (obj3) {
33994 ecode4 = SWIG_AsVal_int(obj3, &val4);
33995 if (!SWIG_IsOK(ecode4)) {
33996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33997 }
33998 arg4 = static_cast< int >(val4);
33999 }
34000 {
34001 PyThreadState* __tstate = wxPyBeginAllowThreads();
34002 (arg1)->Move(arg2,arg3,arg4);
34003 wxPyEndAllowThreads(__tstate);
34004 if (PyErr_Occurred()) SWIG_fail;
34005 }
34006 resultobj = SWIG_Py_Void();
34007 return resultobj;
34008 fail:
34009 return NULL;
34010 }
34011
34012
34013 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34014 PyObject *resultobj = 0;
34015 wxWindow *arg1 = (wxWindow *) 0 ;
34016 wxSize const &arg2_defvalue = wxDefaultSize ;
34017 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 wxSize temp2 ;
34021 PyObject * obj0 = 0 ;
34022 PyObject * obj1 = 0 ;
34023 char * kwnames[] = {
34024 (char *) "self",(char *) "size", NULL
34025 };
34026
34027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34031 }
34032 arg1 = reinterpret_cast< wxWindow * >(argp1);
34033 if (obj1) {
34034 {
34035 arg2 = &temp2;
34036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34037 }
34038 }
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 (arg1)->SetInitialSize((wxSize const &)*arg2);
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 resultobj = SWIG_Py_Void();
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34053 PyObject *resultobj = 0;
34054 wxWindow *arg1 = (wxWindow *) 0 ;
34055 void *argp1 = 0 ;
34056 int res1 = 0 ;
34057 PyObject *swig_obj[1] ;
34058
34059 if (!args) SWIG_fail;
34060 swig_obj[0] = args;
34061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34062 if (!SWIG_IsOK(res1)) {
34063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34064 }
34065 arg1 = reinterpret_cast< wxWindow * >(argp1);
34066 {
34067 PyThreadState* __tstate = wxPyBeginAllowThreads();
34068 (arg1)->Raise();
34069 wxPyEndAllowThreads(__tstate);
34070 if (PyErr_Occurred()) SWIG_fail;
34071 }
34072 resultobj = SWIG_Py_Void();
34073 return resultobj;
34074 fail:
34075 return NULL;
34076 }
34077
34078
34079 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34080 PyObject *resultobj = 0;
34081 wxWindow *arg1 = (wxWindow *) 0 ;
34082 void *argp1 = 0 ;
34083 int res1 = 0 ;
34084 PyObject *swig_obj[1] ;
34085
34086 if (!args) SWIG_fail;
34087 swig_obj[0] = args;
34088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34089 if (!SWIG_IsOK(res1)) {
34090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34091 }
34092 arg1 = reinterpret_cast< wxWindow * >(argp1);
34093 {
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 (arg1)->Lower();
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_Py_Void();
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 wxSize *arg2 = 0 ;
34110 void *argp1 = 0 ;
34111 int res1 = 0 ;
34112 wxSize temp2 ;
34113 PyObject * obj0 = 0 ;
34114 PyObject * obj1 = 0 ;
34115 char * kwnames[] = {
34116 (char *) "self",(char *) "size", NULL
34117 };
34118
34119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34121 if (!SWIG_IsOK(res1)) {
34122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34123 }
34124 arg1 = reinterpret_cast< wxWindow * >(argp1);
34125 {
34126 arg2 = &temp2;
34127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34128 }
34129 {
34130 PyThreadState* __tstate = wxPyBeginAllowThreads();
34131 (arg1)->SetClientSize((wxSize const &)*arg2);
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 resultobj = SWIG_Py_Void();
34136 return resultobj;
34137 fail:
34138 return NULL;
34139 }
34140
34141
34142 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34143 PyObject *resultobj = 0;
34144 wxWindow *arg1 = (wxWindow *) 0 ;
34145 int arg2 ;
34146 int arg3 ;
34147 void *argp1 = 0 ;
34148 int res1 = 0 ;
34149 int val2 ;
34150 int ecode2 = 0 ;
34151 int val3 ;
34152 int ecode3 = 0 ;
34153 PyObject * obj0 = 0 ;
34154 PyObject * obj1 = 0 ;
34155 PyObject * obj2 = 0 ;
34156 char * kwnames[] = {
34157 (char *) "self",(char *) "width",(char *) "height", NULL
34158 };
34159
34160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34162 if (!SWIG_IsOK(res1)) {
34163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34164 }
34165 arg1 = reinterpret_cast< wxWindow * >(argp1);
34166 ecode2 = SWIG_AsVal_int(obj1, &val2);
34167 if (!SWIG_IsOK(ecode2)) {
34168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34169 }
34170 arg2 = static_cast< int >(val2);
34171 ecode3 = SWIG_AsVal_int(obj2, &val3);
34172 if (!SWIG_IsOK(ecode3)) {
34173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34174 }
34175 arg3 = static_cast< int >(val3);
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 (arg1)->SetClientSize(arg2,arg3);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_Py_Void();
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj = 0;
34191 wxWindow *arg1 = (wxWindow *) 0 ;
34192 wxRect *arg2 = 0 ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 wxRect temp2 ;
34196 PyObject * obj0 = 0 ;
34197 PyObject * obj1 = 0 ;
34198 char * kwnames[] = {
34199 (char *) "self",(char *) "rect", NULL
34200 };
34201
34202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34204 if (!SWIG_IsOK(res1)) {
34205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34206 }
34207 arg1 = reinterpret_cast< wxWindow * >(argp1);
34208 {
34209 arg2 = &temp2;
34210 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34211 }
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 (arg1)->SetClientSize((wxRect const &)*arg2);
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 resultobj = SWIG_Py_Void();
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxWindow *arg1 = (wxWindow *) 0 ;
34228 wxPoint result;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject *swig_obj[1] ;
34232
34233 if (!args) SWIG_fail;
34234 swig_obj[0] = args;
34235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 result = ((wxWindow const *)arg1)->GetPosition();
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34247 return resultobj;
34248 fail:
34249 return NULL;
34250 }
34251
34252
34253 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34254 PyObject *resultobj = 0;
34255 wxWindow *arg1 = (wxWindow *) 0 ;
34256 int *arg2 = (int *) 0 ;
34257 int *arg3 = (int *) 0 ;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 int temp2 ;
34261 int res2 = SWIG_TMPOBJ ;
34262 int temp3 ;
34263 int res3 = SWIG_TMPOBJ ;
34264 PyObject *swig_obj[1] ;
34265
34266 arg2 = &temp2;
34267 arg3 = &temp3;
34268 if (!args) SWIG_fail;
34269 swig_obj[0] = args;
34270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34271 if (!SWIG_IsOK(res1)) {
34272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34273 }
34274 arg1 = reinterpret_cast< wxWindow * >(argp1);
34275 {
34276 PyThreadState* __tstate = wxPyBeginAllowThreads();
34277 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34278 wxPyEndAllowThreads(__tstate);
34279 if (PyErr_Occurred()) SWIG_fail;
34280 }
34281 resultobj = SWIG_Py_Void();
34282 if (SWIG_IsTmpObj(res2)) {
34283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34284 } else {
34285 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34287 }
34288 if (SWIG_IsTmpObj(res3)) {
34289 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34290 } else {
34291 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34293 }
34294 return resultobj;
34295 fail:
34296 return NULL;
34297 }
34298
34299
34300 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34301 PyObject *resultobj = 0;
34302 wxWindow *arg1 = (wxWindow *) 0 ;
34303 wxPoint result;
34304 void *argp1 = 0 ;
34305 int res1 = 0 ;
34306 PyObject *swig_obj[1] ;
34307
34308 if (!args) SWIG_fail;
34309 swig_obj[0] = args;
34310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34311 if (!SWIG_IsOK(res1)) {
34312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34313 }
34314 arg1 = reinterpret_cast< wxWindow * >(argp1);
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 result = ((wxWindow const *)arg1)->GetScreenPosition();
34318 wxPyEndAllowThreads(__tstate);
34319 if (PyErr_Occurred()) SWIG_fail;
34320 }
34321 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34322 return resultobj;
34323 fail:
34324 return NULL;
34325 }
34326
34327
34328 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34329 PyObject *resultobj = 0;
34330 wxWindow *arg1 = (wxWindow *) 0 ;
34331 int *arg2 = (int *) 0 ;
34332 int *arg3 = (int *) 0 ;
34333 void *argp1 = 0 ;
34334 int res1 = 0 ;
34335 int temp2 ;
34336 int res2 = SWIG_TMPOBJ ;
34337 int temp3 ;
34338 int res3 = SWIG_TMPOBJ ;
34339 PyObject *swig_obj[1] ;
34340
34341 arg2 = &temp2;
34342 arg3 = &temp3;
34343 if (!args) SWIG_fail;
34344 swig_obj[0] = args;
34345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34346 if (!SWIG_IsOK(res1)) {
34347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34348 }
34349 arg1 = reinterpret_cast< wxWindow * >(argp1);
34350 {
34351 PyThreadState* __tstate = wxPyBeginAllowThreads();
34352 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 resultobj = SWIG_Py_Void();
34357 if (SWIG_IsTmpObj(res2)) {
34358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34359 } else {
34360 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34362 }
34363 if (SWIG_IsTmpObj(res3)) {
34364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34365 } else {
34366 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34368 }
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34376 PyObject *resultobj = 0;
34377 wxWindow *arg1 = (wxWindow *) 0 ;
34378 wxRect result;
34379 void *argp1 = 0 ;
34380 int res1 = 0 ;
34381 PyObject *swig_obj[1] ;
34382
34383 if (!args) SWIG_fail;
34384 swig_obj[0] = args;
34385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34386 if (!SWIG_IsOK(res1)) {
34387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34388 }
34389 arg1 = reinterpret_cast< wxWindow * >(argp1);
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 result = ((wxWindow const *)arg1)->GetScreenRect();
34393 wxPyEndAllowThreads(__tstate);
34394 if (PyErr_Occurred()) SWIG_fail;
34395 }
34396 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34397 return resultobj;
34398 fail:
34399 return NULL;
34400 }
34401
34402
34403 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34404 PyObject *resultobj = 0;
34405 wxWindow *arg1 = (wxWindow *) 0 ;
34406 wxSize result;
34407 void *argp1 = 0 ;
34408 int res1 = 0 ;
34409 PyObject *swig_obj[1] ;
34410
34411 if (!args) SWIG_fail;
34412 swig_obj[0] = args;
34413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34414 if (!SWIG_IsOK(res1)) {
34415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34416 }
34417 arg1 = reinterpret_cast< wxWindow * >(argp1);
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 result = ((wxWindow const *)arg1)->GetSize();
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 int *arg2 = (int *) 0 ;
34435 int *arg3 = (int *) 0 ;
34436 void *argp1 = 0 ;
34437 int res1 = 0 ;
34438 int temp2 ;
34439 int res2 = SWIG_TMPOBJ ;
34440 int temp3 ;
34441 int res3 = SWIG_TMPOBJ ;
34442 PyObject *swig_obj[1] ;
34443
34444 arg2 = &temp2;
34445 arg3 = &temp3;
34446 if (!args) SWIG_fail;
34447 swig_obj[0] = args;
34448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34449 if (!SWIG_IsOK(res1)) {
34450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34451 }
34452 arg1 = reinterpret_cast< wxWindow * >(argp1);
34453 {
34454 PyThreadState* __tstate = wxPyBeginAllowThreads();
34455 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34456 wxPyEndAllowThreads(__tstate);
34457 if (PyErr_Occurred()) SWIG_fail;
34458 }
34459 resultobj = SWIG_Py_Void();
34460 if (SWIG_IsTmpObj(res2)) {
34461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34462 } else {
34463 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34465 }
34466 if (SWIG_IsTmpObj(res3)) {
34467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34468 } else {
34469 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34471 }
34472 return resultobj;
34473 fail:
34474 return NULL;
34475 }
34476
34477
34478 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34479 PyObject *resultobj = 0;
34480 wxWindow *arg1 = (wxWindow *) 0 ;
34481 wxRect result;
34482 void *argp1 = 0 ;
34483 int res1 = 0 ;
34484 PyObject *swig_obj[1] ;
34485
34486 if (!args) SWIG_fail;
34487 swig_obj[0] = args;
34488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34489 if (!SWIG_IsOK(res1)) {
34490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34491 }
34492 arg1 = reinterpret_cast< wxWindow * >(argp1);
34493 {
34494 PyThreadState* __tstate = wxPyBeginAllowThreads();
34495 result = ((wxWindow const *)arg1)->GetRect();
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34500 return resultobj;
34501 fail:
34502 return NULL;
34503 }
34504
34505
34506 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34507 PyObject *resultobj = 0;
34508 wxWindow *arg1 = (wxWindow *) 0 ;
34509 wxSize result;
34510 void *argp1 = 0 ;
34511 int res1 = 0 ;
34512 PyObject *swig_obj[1] ;
34513
34514 if (!args) SWIG_fail;
34515 swig_obj[0] = args;
34516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34517 if (!SWIG_IsOK(res1)) {
34518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34519 }
34520 arg1 = reinterpret_cast< wxWindow * >(argp1);
34521 {
34522 PyThreadState* __tstate = wxPyBeginAllowThreads();
34523 result = ((wxWindow const *)arg1)->GetClientSize();
34524 wxPyEndAllowThreads(__tstate);
34525 if (PyErr_Occurred()) SWIG_fail;
34526 }
34527 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34528 return resultobj;
34529 fail:
34530 return NULL;
34531 }
34532
34533
34534 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34535 PyObject *resultobj = 0;
34536 wxWindow *arg1 = (wxWindow *) 0 ;
34537 int *arg2 = (int *) 0 ;
34538 int *arg3 = (int *) 0 ;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 int temp2 ;
34542 int res2 = SWIG_TMPOBJ ;
34543 int temp3 ;
34544 int res3 = SWIG_TMPOBJ ;
34545 PyObject *swig_obj[1] ;
34546
34547 arg2 = &temp2;
34548 arg3 = &temp3;
34549 if (!args) SWIG_fail;
34550 swig_obj[0] = args;
34551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34554 }
34555 arg1 = reinterpret_cast< wxWindow * >(argp1);
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 resultobj = SWIG_Py_Void();
34563 if (SWIG_IsTmpObj(res2)) {
34564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34565 } else {
34566 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34567 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34568 }
34569 if (SWIG_IsTmpObj(res3)) {
34570 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34571 } else {
34572 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34573 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34574 }
34575 return resultobj;
34576 fail:
34577 return NULL;
34578 }
34579
34580
34581 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34582 PyObject *resultobj = 0;
34583 wxWindow *arg1 = (wxWindow *) 0 ;
34584 wxPoint result;
34585 void *argp1 = 0 ;
34586 int res1 = 0 ;
34587 PyObject *swig_obj[1] ;
34588
34589 if (!args) SWIG_fail;
34590 swig_obj[0] = args;
34591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34592 if (!SWIG_IsOK(res1)) {
34593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34594 }
34595 arg1 = reinterpret_cast< wxWindow * >(argp1);
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 wxRect result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 PyObject *swig_obj[1] ;
34616
34617 if (!args) SWIG_fail;
34618 swig_obj[0] = args;
34619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = ((wxWindow const *)arg1)->GetClientRect();
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34638 PyObject *resultobj = 0;
34639 wxWindow *arg1 = (wxWindow *) 0 ;
34640 wxSize result;
34641 void *argp1 = 0 ;
34642 int res1 = 0 ;
34643 PyObject *swig_obj[1] ;
34644
34645 if (!args) SWIG_fail;
34646 swig_obj[0] = args;
34647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34648 if (!SWIG_IsOK(res1)) {
34649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34650 }
34651 arg1 = reinterpret_cast< wxWindow * >(argp1);
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 result = ((wxWindow const *)arg1)->GetBestSize();
34655 wxPyEndAllowThreads(__tstate);
34656 if (PyErr_Occurred()) SWIG_fail;
34657 }
34658 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34659 return resultobj;
34660 fail:
34661 return NULL;
34662 }
34663
34664
34665 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34666 PyObject *resultobj = 0;
34667 wxWindow *arg1 = (wxWindow *) 0 ;
34668 int *arg2 = (int *) 0 ;
34669 int *arg3 = (int *) 0 ;
34670 void *argp1 = 0 ;
34671 int res1 = 0 ;
34672 int temp2 ;
34673 int res2 = SWIG_TMPOBJ ;
34674 int temp3 ;
34675 int res3 = SWIG_TMPOBJ ;
34676 PyObject *swig_obj[1] ;
34677
34678 arg2 = &temp2;
34679 arg3 = &temp3;
34680 if (!args) SWIG_fail;
34681 swig_obj[0] = args;
34682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34683 if (!SWIG_IsOK(res1)) {
34684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34685 }
34686 arg1 = reinterpret_cast< wxWindow * >(argp1);
34687 {
34688 PyThreadState* __tstate = wxPyBeginAllowThreads();
34689 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34690 wxPyEndAllowThreads(__tstate);
34691 if (PyErr_Occurred()) SWIG_fail;
34692 }
34693 resultobj = SWIG_Py_Void();
34694 if (SWIG_IsTmpObj(res2)) {
34695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34696 } else {
34697 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34699 }
34700 if (SWIG_IsTmpObj(res3)) {
34701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34702 } else {
34703 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34705 }
34706 return resultobj;
34707 fail:
34708 return NULL;
34709 }
34710
34711
34712 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34713 PyObject *resultobj = 0;
34714 wxWindow *arg1 = (wxWindow *) 0 ;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 PyObject *swig_obj[1] ;
34718
34719 if (!args) SWIG_fail;
34720 swig_obj[0] = args;
34721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34722 if (!SWIG_IsOK(res1)) {
34723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34724 }
34725 arg1 = reinterpret_cast< wxWindow * >(argp1);
34726 {
34727 PyThreadState* __tstate = wxPyBeginAllowThreads();
34728 (arg1)->InvalidateBestSize();
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 resultobj = SWIG_Py_Void();
34733 return resultobj;
34734 fail:
34735 return NULL;
34736 }
34737
34738
34739 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34740 PyObject *resultobj = 0;
34741 wxWindow *arg1 = (wxWindow *) 0 ;
34742 wxSize *arg2 = 0 ;
34743 void *argp1 = 0 ;
34744 int res1 = 0 ;
34745 wxSize temp2 ;
34746 PyObject * obj0 = 0 ;
34747 PyObject * obj1 = 0 ;
34748 char * kwnames[] = {
34749 (char *) "self",(char *) "size", NULL
34750 };
34751
34752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34754 if (!SWIG_IsOK(res1)) {
34755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34756 }
34757 arg1 = reinterpret_cast< wxWindow * >(argp1);
34758 {
34759 arg2 = &temp2;
34760 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34761 }
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 resultobj = SWIG_Py_Void();
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34776 PyObject *resultobj = 0;
34777 wxWindow *arg1 = (wxWindow *) 0 ;
34778 wxSize result;
34779 void *argp1 = 0 ;
34780 int res1 = 0 ;
34781 PyObject *swig_obj[1] ;
34782
34783 if (!args) SWIG_fail;
34784 swig_obj[0] = args;
34785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34786 if (!SWIG_IsOK(res1)) {
34787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34788 }
34789 arg1 = reinterpret_cast< wxWindow * >(argp1);
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34797 return resultobj;
34798 fail:
34799 return NULL;
34800 }
34801
34802
34803 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34804 PyObject *resultobj = 0;
34805 wxWindow *arg1 = (wxWindow *) 0 ;
34806 int arg2 = (int) wxBOTH ;
34807 void *argp1 = 0 ;
34808 int res1 = 0 ;
34809 int val2 ;
34810 int ecode2 = 0 ;
34811 PyObject * obj0 = 0 ;
34812 PyObject * obj1 = 0 ;
34813 char * kwnames[] = {
34814 (char *) "self",(char *) "direction", NULL
34815 };
34816
34817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34821 }
34822 arg1 = reinterpret_cast< wxWindow * >(argp1);
34823 if (obj1) {
34824 ecode2 = SWIG_AsVal_int(obj1, &val2);
34825 if (!SWIG_IsOK(ecode2)) {
34826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34827 }
34828 arg2 = static_cast< int >(val2);
34829 }
34830 {
34831 PyThreadState* __tstate = wxPyBeginAllowThreads();
34832 (arg1)->Center(arg2);
34833 wxPyEndAllowThreads(__tstate);
34834 if (PyErr_Occurred()) SWIG_fail;
34835 }
34836 resultobj = SWIG_Py_Void();
34837 return resultobj;
34838 fail:
34839 return NULL;
34840 }
34841
34842
34843 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34844 PyObject *resultobj = 0;
34845 wxWindow *arg1 = (wxWindow *) 0 ;
34846 int arg2 = (int) wxBOTH ;
34847 void *argp1 = 0 ;
34848 int res1 = 0 ;
34849 int val2 ;
34850 int ecode2 = 0 ;
34851 PyObject * obj0 = 0 ;
34852 PyObject * obj1 = 0 ;
34853 char * kwnames[] = {
34854 (char *) "self",(char *) "dir", NULL
34855 };
34856
34857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 if (obj1) {
34864 ecode2 = SWIG_AsVal_int(obj1, &val2);
34865 if (!SWIG_IsOK(ecode2)) {
34866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34867 }
34868 arg2 = static_cast< int >(val2);
34869 }
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 (arg1)->CenterOnParent(arg2);
34873 wxPyEndAllowThreads(__tstate);
34874 if (PyErr_Occurred()) SWIG_fail;
34875 }
34876 resultobj = SWIG_Py_Void();
34877 return resultobj;
34878 fail:
34879 return NULL;
34880 }
34881
34882
34883 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34884 PyObject *resultobj = 0;
34885 wxWindow *arg1 = (wxWindow *) 0 ;
34886 void *argp1 = 0 ;
34887 int res1 = 0 ;
34888 PyObject *swig_obj[1] ;
34889
34890 if (!args) SWIG_fail;
34891 swig_obj[0] = args;
34892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34893 if (!SWIG_IsOK(res1)) {
34894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34895 }
34896 arg1 = reinterpret_cast< wxWindow * >(argp1);
34897 {
34898 PyThreadState* __tstate = wxPyBeginAllowThreads();
34899 (arg1)->Fit();
34900 wxPyEndAllowThreads(__tstate);
34901 if (PyErr_Occurred()) SWIG_fail;
34902 }
34903 resultobj = SWIG_Py_Void();
34904 return resultobj;
34905 fail:
34906 return NULL;
34907 }
34908
34909
34910 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34911 PyObject *resultobj = 0;
34912 wxWindow *arg1 = (wxWindow *) 0 ;
34913 void *argp1 = 0 ;
34914 int res1 = 0 ;
34915 PyObject *swig_obj[1] ;
34916
34917 if (!args) SWIG_fail;
34918 swig_obj[0] = args;
34919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34920 if (!SWIG_IsOK(res1)) {
34921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34922 }
34923 arg1 = reinterpret_cast< wxWindow * >(argp1);
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 (arg1)->FitInside();
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 resultobj = SWIG_Py_Void();
34931 return resultobj;
34932 fail:
34933 return NULL;
34934 }
34935
34936
34937 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34938 PyObject *resultobj = 0;
34939 wxWindow *arg1 = (wxWindow *) 0 ;
34940 int arg2 ;
34941 int arg3 ;
34942 int arg4 = (int) -1 ;
34943 int arg5 = (int) -1 ;
34944 int arg6 = (int) -1 ;
34945 int arg7 = (int) -1 ;
34946 void *argp1 = 0 ;
34947 int res1 = 0 ;
34948 int val2 ;
34949 int ecode2 = 0 ;
34950 int val3 ;
34951 int ecode3 = 0 ;
34952 int val4 ;
34953 int ecode4 = 0 ;
34954 int val5 ;
34955 int ecode5 = 0 ;
34956 int val6 ;
34957 int ecode6 = 0 ;
34958 int val7 ;
34959 int ecode7 = 0 ;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 PyObject * obj2 = 0 ;
34963 PyObject * obj3 = 0 ;
34964 PyObject * obj4 = 0 ;
34965 PyObject * obj5 = 0 ;
34966 PyObject * obj6 = 0 ;
34967 char * kwnames[] = {
34968 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34969 };
34970
34971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34975 }
34976 arg1 = reinterpret_cast< wxWindow * >(argp1);
34977 ecode2 = SWIG_AsVal_int(obj1, &val2);
34978 if (!SWIG_IsOK(ecode2)) {
34979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34980 }
34981 arg2 = static_cast< int >(val2);
34982 ecode3 = SWIG_AsVal_int(obj2, &val3);
34983 if (!SWIG_IsOK(ecode3)) {
34984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34985 }
34986 arg3 = static_cast< int >(val3);
34987 if (obj3) {
34988 ecode4 = SWIG_AsVal_int(obj3, &val4);
34989 if (!SWIG_IsOK(ecode4)) {
34990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34991 }
34992 arg4 = static_cast< int >(val4);
34993 }
34994 if (obj4) {
34995 ecode5 = SWIG_AsVal_int(obj4, &val5);
34996 if (!SWIG_IsOK(ecode5)) {
34997 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34998 }
34999 arg5 = static_cast< int >(val5);
35000 }
35001 if (obj5) {
35002 ecode6 = SWIG_AsVal_int(obj5, &val6);
35003 if (!SWIG_IsOK(ecode6)) {
35004 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35005 }
35006 arg6 = static_cast< int >(val6);
35007 }
35008 if (obj6) {
35009 ecode7 = SWIG_AsVal_int(obj6, &val7);
35010 if (!SWIG_IsOK(ecode7)) {
35011 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35012 }
35013 arg7 = static_cast< int >(val7);
35014 }
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35018 wxPyEndAllowThreads(__tstate);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 }
35021 resultobj = SWIG_Py_Void();
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35029 PyObject *resultobj = 0;
35030 wxWindow *arg1 = (wxWindow *) 0 ;
35031 wxSize *arg2 = 0 ;
35032 wxSize const &arg3_defvalue = wxDefaultSize ;
35033 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35034 wxSize const &arg4_defvalue = wxDefaultSize ;
35035 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 wxSize temp2 ;
35039 wxSize temp3 ;
35040 wxSize temp4 ;
35041 PyObject * obj0 = 0 ;
35042 PyObject * obj1 = 0 ;
35043 PyObject * obj2 = 0 ;
35044 PyObject * obj3 = 0 ;
35045 char * kwnames[] = {
35046 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35047 };
35048
35049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35053 }
35054 arg1 = reinterpret_cast< wxWindow * >(argp1);
35055 {
35056 arg2 = &temp2;
35057 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35058 }
35059 if (obj2) {
35060 {
35061 arg3 = &temp3;
35062 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35063 }
35064 }
35065 if (obj3) {
35066 {
35067 arg4 = &temp4;
35068 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35069 }
35070 }
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 resultobj = SWIG_Py_Void();
35078 return resultobj;
35079 fail:
35080 return NULL;
35081 }
35082
35083
35084 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35085 PyObject *resultobj = 0;
35086 wxWindow *arg1 = (wxWindow *) 0 ;
35087 int arg2 ;
35088 int arg3 ;
35089 int arg4 = (int) -1 ;
35090 int arg5 = (int) -1 ;
35091 void *argp1 = 0 ;
35092 int res1 = 0 ;
35093 int val2 ;
35094 int ecode2 = 0 ;
35095 int val3 ;
35096 int ecode3 = 0 ;
35097 int val4 ;
35098 int ecode4 = 0 ;
35099 int val5 ;
35100 int ecode5 = 0 ;
35101 PyObject * obj0 = 0 ;
35102 PyObject * obj1 = 0 ;
35103 PyObject * obj2 = 0 ;
35104 PyObject * obj3 = 0 ;
35105 PyObject * obj4 = 0 ;
35106 char * kwnames[] = {
35107 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35108 };
35109
35110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35112 if (!SWIG_IsOK(res1)) {
35113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35114 }
35115 arg1 = reinterpret_cast< wxWindow * >(argp1);
35116 ecode2 = SWIG_AsVal_int(obj1, &val2);
35117 if (!SWIG_IsOK(ecode2)) {
35118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35119 }
35120 arg2 = static_cast< int >(val2);
35121 ecode3 = SWIG_AsVal_int(obj2, &val3);
35122 if (!SWIG_IsOK(ecode3)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35124 }
35125 arg3 = static_cast< int >(val3);
35126 if (obj3) {
35127 ecode4 = SWIG_AsVal_int(obj3, &val4);
35128 if (!SWIG_IsOK(ecode4)) {
35129 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35130 }
35131 arg4 = static_cast< int >(val4);
35132 }
35133 if (obj4) {
35134 ecode5 = SWIG_AsVal_int(obj4, &val5);
35135 if (!SWIG_IsOK(ecode5)) {
35136 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35137 }
35138 arg5 = static_cast< int >(val5);
35139 }
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 resultobj = SWIG_Py_Void();
35147 return resultobj;
35148 fail:
35149 return NULL;
35150 }
35151
35152
35153 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35154 PyObject *resultobj = 0;
35155 wxWindow *arg1 = (wxWindow *) 0 ;
35156 wxSize *arg2 = 0 ;
35157 wxSize const &arg3_defvalue = wxDefaultSize ;
35158 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35159 void *argp1 = 0 ;
35160 int res1 = 0 ;
35161 wxSize temp2 ;
35162 wxSize temp3 ;
35163 PyObject * obj0 = 0 ;
35164 PyObject * obj1 = 0 ;
35165 PyObject * obj2 = 0 ;
35166 char * kwnames[] = {
35167 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35168 };
35169
35170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35172 if (!SWIG_IsOK(res1)) {
35173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35174 }
35175 arg1 = reinterpret_cast< wxWindow * >(argp1);
35176 {
35177 arg2 = &temp2;
35178 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35179 }
35180 if (obj2) {
35181 {
35182 arg3 = &temp3;
35183 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35184 }
35185 }
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_Py_Void();
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 wxSize result;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 PyObject *swig_obj[1] ;
35206
35207 if (!args) SWIG_fail;
35208 swig_obj[0] = args;
35209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35210 if (!SWIG_IsOK(res1)) {
35211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35212 }
35213 arg1 = reinterpret_cast< wxWindow * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 result = ((wxWindow const *)arg1)->GetMaxSize();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35228 PyObject *resultobj = 0;
35229 wxWindow *arg1 = (wxWindow *) 0 ;
35230 wxSize result;
35231 void *argp1 = 0 ;
35232 int res1 = 0 ;
35233 PyObject *swig_obj[1] ;
35234
35235 if (!args) SWIG_fail;
35236 swig_obj[0] = args;
35237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35238 if (!SWIG_IsOK(res1)) {
35239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35240 }
35241 arg1 = reinterpret_cast< wxWindow * >(argp1);
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 result = ((wxWindow const *)arg1)->GetMinSize();
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35249 return resultobj;
35250 fail:
35251 return NULL;
35252 }
35253
35254
35255 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35256 PyObject *resultobj = 0;
35257 wxWindow *arg1 = (wxWindow *) 0 ;
35258 wxSize *arg2 = 0 ;
35259 void *argp1 = 0 ;
35260 int res1 = 0 ;
35261 wxSize temp2 ;
35262 PyObject * obj0 = 0 ;
35263 PyObject * obj1 = 0 ;
35264 char * kwnames[] = {
35265 (char *) "self",(char *) "minSize", NULL
35266 };
35267
35268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35270 if (!SWIG_IsOK(res1)) {
35271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35272 }
35273 arg1 = reinterpret_cast< wxWindow * >(argp1);
35274 {
35275 arg2 = &temp2;
35276 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35277 }
35278 {
35279 PyThreadState* __tstate = wxPyBeginAllowThreads();
35280 (arg1)->SetMinSize((wxSize const &)*arg2);
35281 wxPyEndAllowThreads(__tstate);
35282 if (PyErr_Occurred()) SWIG_fail;
35283 }
35284 resultobj = SWIG_Py_Void();
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj = 0;
35293 wxWindow *arg1 = (wxWindow *) 0 ;
35294 wxSize *arg2 = 0 ;
35295 void *argp1 = 0 ;
35296 int res1 = 0 ;
35297 wxSize temp2 ;
35298 PyObject * obj0 = 0 ;
35299 PyObject * obj1 = 0 ;
35300 char * kwnames[] = {
35301 (char *) "self",(char *) "maxSize", NULL
35302 };
35303
35304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35306 if (!SWIG_IsOK(res1)) {
35307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35308 }
35309 arg1 = reinterpret_cast< wxWindow * >(argp1);
35310 {
35311 arg2 = &temp2;
35312 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35313 }
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 (arg1)->SetMaxSize((wxSize const &)*arg2);
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 resultobj = SWIG_Py_Void();
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35328 PyObject *resultobj = 0;
35329 wxWindow *arg1 = (wxWindow *) 0 ;
35330 int result;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 PyObject *swig_obj[1] ;
35334
35335 if (!args) SWIG_fail;
35336 swig_obj[0] = args;
35337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35338 if (!SWIG_IsOK(res1)) {
35339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35340 }
35341 arg1 = reinterpret_cast< wxWindow * >(argp1);
35342 {
35343 PyThreadState* __tstate = wxPyBeginAllowThreads();
35344 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35345 wxPyEndAllowThreads(__tstate);
35346 if (PyErr_Occurred()) SWIG_fail;
35347 }
35348 resultobj = SWIG_From_int(static_cast< int >(result));
35349 return resultobj;
35350 fail:
35351 return NULL;
35352 }
35353
35354
35355 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35356 PyObject *resultobj = 0;
35357 wxWindow *arg1 = (wxWindow *) 0 ;
35358 int result;
35359 void *argp1 = 0 ;
35360 int res1 = 0 ;
35361 PyObject *swig_obj[1] ;
35362
35363 if (!args) SWIG_fail;
35364 swig_obj[0] = args;
35365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35366 if (!SWIG_IsOK(res1)) {
35367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35368 }
35369 arg1 = reinterpret_cast< wxWindow * >(argp1);
35370 {
35371 PyThreadState* __tstate = wxPyBeginAllowThreads();
35372 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35373 wxPyEndAllowThreads(__tstate);
35374 if (PyErr_Occurred()) SWIG_fail;
35375 }
35376 resultobj = SWIG_From_int(static_cast< int >(result));
35377 return resultobj;
35378 fail:
35379 return NULL;
35380 }
35381
35382
35383 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35384 PyObject *resultobj = 0;
35385 wxWindow *arg1 = (wxWindow *) 0 ;
35386 int result;
35387 void *argp1 = 0 ;
35388 int res1 = 0 ;
35389 PyObject *swig_obj[1] ;
35390
35391 if (!args) SWIG_fail;
35392 swig_obj[0] = args;
35393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35394 if (!SWIG_IsOK(res1)) {
35395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35396 }
35397 arg1 = reinterpret_cast< wxWindow * >(argp1);
35398 {
35399 PyThreadState* __tstate = wxPyBeginAllowThreads();
35400 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35401 wxPyEndAllowThreads(__tstate);
35402 if (PyErr_Occurred()) SWIG_fail;
35403 }
35404 resultobj = SWIG_From_int(static_cast< int >(result));
35405 return resultobj;
35406 fail:
35407 return NULL;
35408 }
35409
35410
35411 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35412 PyObject *resultobj = 0;
35413 wxWindow *arg1 = (wxWindow *) 0 ;
35414 int result;
35415 void *argp1 = 0 ;
35416 int res1 = 0 ;
35417 PyObject *swig_obj[1] ;
35418
35419 if (!args) SWIG_fail;
35420 swig_obj[0] = args;
35421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35422 if (!SWIG_IsOK(res1)) {
35423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35424 }
35425 arg1 = reinterpret_cast< wxWindow * >(argp1);
35426 {
35427 PyThreadState* __tstate = wxPyBeginAllowThreads();
35428 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35429 wxPyEndAllowThreads(__tstate);
35430 if (PyErr_Occurred()) SWIG_fail;
35431 }
35432 resultobj = SWIG_From_int(static_cast< int >(result));
35433 return resultobj;
35434 fail:
35435 return NULL;
35436 }
35437
35438
35439 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35440 PyObject *resultobj = 0;
35441 wxWindow *arg1 = (wxWindow *) 0 ;
35442 wxSize *arg2 = 0 ;
35443 void *argp1 = 0 ;
35444 int res1 = 0 ;
35445 wxSize temp2 ;
35446 PyObject * obj0 = 0 ;
35447 PyObject * obj1 = 0 ;
35448 char * kwnames[] = {
35449 (char *) "self",(char *) "size", NULL
35450 };
35451
35452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35454 if (!SWIG_IsOK(res1)) {
35455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35456 }
35457 arg1 = reinterpret_cast< wxWindow * >(argp1);
35458 {
35459 arg2 = &temp2;
35460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35461 }
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 resultobj = SWIG_Py_Void();
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35476 PyObject *resultobj = 0;
35477 wxWindow *arg1 = (wxWindow *) 0 ;
35478 int arg2 ;
35479 int arg3 ;
35480 void *argp1 = 0 ;
35481 int res1 = 0 ;
35482 int val2 ;
35483 int ecode2 = 0 ;
35484 int val3 ;
35485 int ecode3 = 0 ;
35486 PyObject * obj0 = 0 ;
35487 PyObject * obj1 = 0 ;
35488 PyObject * obj2 = 0 ;
35489 char * kwnames[] = {
35490 (char *) "self",(char *) "w",(char *) "h", NULL
35491 };
35492
35493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35495 if (!SWIG_IsOK(res1)) {
35496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35497 }
35498 arg1 = reinterpret_cast< wxWindow * >(argp1);
35499 ecode2 = SWIG_AsVal_int(obj1, &val2);
35500 if (!SWIG_IsOK(ecode2)) {
35501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35502 }
35503 arg2 = static_cast< int >(val2);
35504 ecode3 = SWIG_AsVal_int(obj2, &val3);
35505 if (!SWIG_IsOK(ecode3)) {
35506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35507 }
35508 arg3 = static_cast< int >(val3);
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 (arg1)->SetVirtualSize(arg2,arg3);
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 resultobj = SWIG_Py_Void();
35516 return resultobj;
35517 fail:
35518 return NULL;
35519 }
35520
35521
35522 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35523 PyObject *resultobj = 0;
35524 wxWindow *arg1 = (wxWindow *) 0 ;
35525 wxSize result;
35526 void *argp1 = 0 ;
35527 int res1 = 0 ;
35528 PyObject *swig_obj[1] ;
35529
35530 if (!args) SWIG_fail;
35531 swig_obj[0] = args;
35532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35533 if (!SWIG_IsOK(res1)) {
35534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35535 }
35536 arg1 = reinterpret_cast< wxWindow * >(argp1);
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 result = ((wxWindow const *)arg1)->GetVirtualSize();
35540 wxPyEndAllowThreads(__tstate);
35541 if (PyErr_Occurred()) SWIG_fail;
35542 }
35543 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35544 return resultobj;
35545 fail:
35546 return NULL;
35547 }
35548
35549
35550 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35551 PyObject *resultobj = 0;
35552 wxWindow *arg1 = (wxWindow *) 0 ;
35553 int *arg2 = (int *) 0 ;
35554 int *arg3 = (int *) 0 ;
35555 void *argp1 = 0 ;
35556 int res1 = 0 ;
35557 int temp2 ;
35558 int res2 = SWIG_TMPOBJ ;
35559 int temp3 ;
35560 int res3 = SWIG_TMPOBJ ;
35561 PyObject *swig_obj[1] ;
35562
35563 arg2 = &temp2;
35564 arg3 = &temp3;
35565 if (!args) SWIG_fail;
35566 swig_obj[0] = args;
35567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35568 if (!SWIG_IsOK(res1)) {
35569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35570 }
35571 arg1 = reinterpret_cast< wxWindow * >(argp1);
35572 {
35573 PyThreadState* __tstate = wxPyBeginAllowThreads();
35574 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35575 wxPyEndAllowThreads(__tstate);
35576 if (PyErr_Occurred()) SWIG_fail;
35577 }
35578 resultobj = SWIG_Py_Void();
35579 if (SWIG_IsTmpObj(res2)) {
35580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35581 } else {
35582 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35584 }
35585 if (SWIG_IsTmpObj(res3)) {
35586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35587 } else {
35588 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35590 }
35591 return resultobj;
35592 fail:
35593 return NULL;
35594 }
35595
35596
35597 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35598 PyObject *resultobj = 0;
35599 wxWindow *arg1 = (wxWindow *) 0 ;
35600 wxSize result;
35601 void *argp1 = 0 ;
35602 int res1 = 0 ;
35603 PyObject *swig_obj[1] ;
35604
35605 if (!args) SWIG_fail;
35606 swig_obj[0] = args;
35607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35608 if (!SWIG_IsOK(res1)) {
35609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35610 }
35611 arg1 = reinterpret_cast< wxWindow * >(argp1);
35612 {
35613 PyThreadState* __tstate = wxPyBeginAllowThreads();
35614 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35615 wxPyEndAllowThreads(__tstate);
35616 if (PyErr_Occurred()) SWIG_fail;
35617 }
35618 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 wxSize result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 PyObject *swig_obj[1] ;
35632
35633 if (!args) SWIG_fail;
35634 swig_obj[0] = args;
35635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35636 if (!SWIG_IsOK(res1)) {
35637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35638 }
35639 arg1 = reinterpret_cast< wxWindow * >(argp1);
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35647 return resultobj;
35648 fail:
35649 return NULL;
35650 }
35651
35652
35653 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35654 PyObject *resultobj = 0;
35655 wxWindow *arg1 = (wxWindow *) 0 ;
35656 bool arg2 = (bool) true ;
35657 bool result;
35658 void *argp1 = 0 ;
35659 int res1 = 0 ;
35660 bool val2 ;
35661 int ecode2 = 0 ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 char * kwnames[] = {
35665 (char *) "self",(char *) "show", NULL
35666 };
35667
35668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35670 if (!SWIG_IsOK(res1)) {
35671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35672 }
35673 arg1 = reinterpret_cast< wxWindow * >(argp1);
35674 if (obj1) {
35675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35676 if (!SWIG_IsOK(ecode2)) {
35677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35678 }
35679 arg2 = static_cast< bool >(val2);
35680 }
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 result = (bool)(arg1)->Show(arg2);
35684 wxPyEndAllowThreads(__tstate);
35685 if (PyErr_Occurred()) SWIG_fail;
35686 }
35687 {
35688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35689 }
35690 return resultobj;
35691 fail:
35692 return NULL;
35693 }
35694
35695
35696 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35697 PyObject *resultobj = 0;
35698 wxWindow *arg1 = (wxWindow *) 0 ;
35699 bool result;
35700 void *argp1 = 0 ;
35701 int res1 = 0 ;
35702 PyObject *swig_obj[1] ;
35703
35704 if (!args) SWIG_fail;
35705 swig_obj[0] = args;
35706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35707 if (!SWIG_IsOK(res1)) {
35708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35709 }
35710 arg1 = reinterpret_cast< wxWindow * >(argp1);
35711 {
35712 PyThreadState* __tstate = wxPyBeginAllowThreads();
35713 result = (bool)(arg1)->Hide();
35714 wxPyEndAllowThreads(__tstate);
35715 if (PyErr_Occurred()) SWIG_fail;
35716 }
35717 {
35718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35719 }
35720 return resultobj;
35721 fail:
35722 return NULL;
35723 }
35724
35725
35726 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35727 PyObject *resultobj = 0;
35728 wxWindow *arg1 = (wxWindow *) 0 ;
35729 bool arg2 = (bool) true ;
35730 bool result;
35731 void *argp1 = 0 ;
35732 int res1 = 0 ;
35733 bool val2 ;
35734 int ecode2 = 0 ;
35735 PyObject * obj0 = 0 ;
35736 PyObject * obj1 = 0 ;
35737 char * kwnames[] = {
35738 (char *) "self",(char *) "enable", NULL
35739 };
35740
35741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35743 if (!SWIG_IsOK(res1)) {
35744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35745 }
35746 arg1 = reinterpret_cast< wxWindow * >(argp1);
35747 if (obj1) {
35748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35749 if (!SWIG_IsOK(ecode2)) {
35750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35751 }
35752 arg2 = static_cast< bool >(val2);
35753 }
35754 {
35755 PyThreadState* __tstate = wxPyBeginAllowThreads();
35756 result = (bool)(arg1)->Enable(arg2);
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35762 }
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35770 PyObject *resultobj = 0;
35771 wxWindow *arg1 = (wxWindow *) 0 ;
35772 bool result;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 PyObject *swig_obj[1] ;
35776
35777 if (!args) SWIG_fail;
35778 swig_obj[0] = args;
35779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35780 if (!SWIG_IsOK(res1)) {
35781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35782 }
35783 arg1 = reinterpret_cast< wxWindow * >(argp1);
35784 {
35785 PyThreadState* __tstate = wxPyBeginAllowThreads();
35786 result = (bool)(arg1)->Disable();
35787 wxPyEndAllowThreads(__tstate);
35788 if (PyErr_Occurred()) SWIG_fail;
35789 }
35790 {
35791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35792 }
35793 return resultobj;
35794 fail:
35795 return NULL;
35796 }
35797
35798
35799 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35800 PyObject *resultobj = 0;
35801 wxWindow *arg1 = (wxWindow *) 0 ;
35802 bool result;
35803 void *argp1 = 0 ;
35804 int res1 = 0 ;
35805 PyObject *swig_obj[1] ;
35806
35807 if (!args) SWIG_fail;
35808 swig_obj[0] = args;
35809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35810 if (!SWIG_IsOK(res1)) {
35811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35812 }
35813 arg1 = reinterpret_cast< wxWindow * >(argp1);
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 result = (bool)((wxWindow const *)arg1)->IsShown();
35817 wxPyEndAllowThreads(__tstate);
35818 if (PyErr_Occurred()) SWIG_fail;
35819 }
35820 {
35821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35822 }
35823 return resultobj;
35824 fail:
35825 return NULL;
35826 }
35827
35828
35829 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35830 PyObject *resultobj = 0;
35831 wxWindow *arg1 = (wxWindow *) 0 ;
35832 bool result;
35833 void *argp1 = 0 ;
35834 int res1 = 0 ;
35835 PyObject *swig_obj[1] ;
35836
35837 if (!args) SWIG_fail;
35838 swig_obj[0] = args;
35839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35840 if (!SWIG_IsOK(res1)) {
35841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35842 }
35843 arg1 = reinterpret_cast< wxWindow * >(argp1);
35844 {
35845 PyThreadState* __tstate = wxPyBeginAllowThreads();
35846 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35847 wxPyEndAllowThreads(__tstate);
35848 if (PyErr_Occurred()) SWIG_fail;
35849 }
35850 {
35851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35852 }
35853 return resultobj;
35854 fail:
35855 return NULL;
35856 }
35857
35858
35859 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35860 PyObject *resultobj = 0;
35861 wxWindow *arg1 = (wxWindow *) 0 ;
35862 bool result;
35863 void *argp1 = 0 ;
35864 int res1 = 0 ;
35865 PyObject *swig_obj[1] ;
35866
35867 if (!args) SWIG_fail;
35868 swig_obj[0] = args;
35869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35870 if (!SWIG_IsOK(res1)) {
35871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35872 }
35873 arg1 = reinterpret_cast< wxWindow * >(argp1);
35874 {
35875 PyThreadState* __tstate = wxPyBeginAllowThreads();
35876 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
35877 wxPyEndAllowThreads(__tstate);
35878 if (PyErr_Occurred()) SWIG_fail;
35879 }
35880 {
35881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35882 }
35883 return resultobj;
35884 fail:
35885 return NULL;
35886 }
35887
35888
35889 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35890 PyObject *resultobj = 0;
35891 wxWindow *arg1 = (wxWindow *) 0 ;
35892 bool result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 PyObject *swig_obj[1] ;
35896
35897 if (!args) SWIG_fail;
35898 swig_obj[0] = args;
35899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35900 if (!SWIG_IsOK(res1)) {
35901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35902 }
35903 arg1 = reinterpret_cast< wxWindow * >(argp1);
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 {
35911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35912 }
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35920 PyObject *resultobj = 0;
35921 wxWindow *arg1 = (wxWindow *) 0 ;
35922 long arg2 ;
35923 void *argp1 = 0 ;
35924 int res1 = 0 ;
35925 long val2 ;
35926 int ecode2 = 0 ;
35927 PyObject * obj0 = 0 ;
35928 PyObject * obj1 = 0 ;
35929 char * kwnames[] = {
35930 (char *) "self",(char *) "style", NULL
35931 };
35932
35933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35935 if (!SWIG_IsOK(res1)) {
35936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35937 }
35938 arg1 = reinterpret_cast< wxWindow * >(argp1);
35939 ecode2 = SWIG_AsVal_long(obj1, &val2);
35940 if (!SWIG_IsOK(ecode2)) {
35941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35942 }
35943 arg2 = static_cast< long >(val2);
35944 {
35945 PyThreadState* __tstate = wxPyBeginAllowThreads();
35946 (arg1)->SetWindowStyleFlag(arg2);
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 resultobj = SWIG_Py_Void();
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35958 PyObject *resultobj = 0;
35959 wxWindow *arg1 = (wxWindow *) 0 ;
35960 long result;
35961 void *argp1 = 0 ;
35962 int res1 = 0 ;
35963 PyObject *swig_obj[1] ;
35964
35965 if (!args) SWIG_fail;
35966 swig_obj[0] = args;
35967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35968 if (!SWIG_IsOK(res1)) {
35969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35970 }
35971 arg1 = reinterpret_cast< wxWindow * >(argp1);
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_From_long(static_cast< long >(result));
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35986 PyObject *resultobj = 0;
35987 wxWindow *arg1 = (wxWindow *) 0 ;
35988 int arg2 ;
35989 bool result;
35990 void *argp1 = 0 ;
35991 int res1 = 0 ;
35992 int val2 ;
35993 int ecode2 = 0 ;
35994 PyObject * obj0 = 0 ;
35995 PyObject * obj1 = 0 ;
35996 char * kwnames[] = {
35997 (char *) "self",(char *) "flag", NULL
35998 };
35999
36000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36002 if (!SWIG_IsOK(res1)) {
36003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36004 }
36005 arg1 = reinterpret_cast< wxWindow * >(argp1);
36006 ecode2 = SWIG_AsVal_int(obj1, &val2);
36007 if (!SWIG_IsOK(ecode2)) {
36008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36009 }
36010 arg2 = static_cast< int >(val2);
36011 {
36012 PyThreadState* __tstate = wxPyBeginAllowThreads();
36013 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36014 wxPyEndAllowThreads(__tstate);
36015 if (PyErr_Occurred()) SWIG_fail;
36016 }
36017 {
36018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36019 }
36020 return resultobj;
36021 fail:
36022 return NULL;
36023 }
36024
36025
36026 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36027 PyObject *resultobj = 0;
36028 wxWindow *arg1 = (wxWindow *) 0 ;
36029 bool result;
36030 void *argp1 = 0 ;
36031 int res1 = 0 ;
36032 PyObject *swig_obj[1] ;
36033
36034 if (!args) SWIG_fail;
36035 swig_obj[0] = args;
36036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36037 if (!SWIG_IsOK(res1)) {
36038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36039 }
36040 arg1 = reinterpret_cast< wxWindow * >(argp1);
36041 {
36042 PyThreadState* __tstate = wxPyBeginAllowThreads();
36043 result = (bool)((wxWindow const *)arg1)->IsRetained();
36044 wxPyEndAllowThreads(__tstate);
36045 if (PyErr_Occurred()) SWIG_fail;
36046 }
36047 {
36048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36049 }
36050 return resultobj;
36051 fail:
36052 return NULL;
36053 }
36054
36055
36056 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36057 PyObject *resultobj = 0;
36058 wxWindow *arg1 = (wxWindow *) 0 ;
36059 int arg2 ;
36060 bool result;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 int val2 ;
36064 int ecode2 = 0 ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char * kwnames[] = {
36068 (char *) "self",(char *) "flag", NULL
36069 };
36070
36071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36073 if (!SWIG_IsOK(res1)) {
36074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36075 }
36076 arg1 = reinterpret_cast< wxWindow * >(argp1);
36077 ecode2 = SWIG_AsVal_int(obj1, &val2);
36078 if (!SWIG_IsOK(ecode2)) {
36079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36080 }
36081 arg2 = static_cast< int >(val2);
36082 {
36083 PyThreadState* __tstate = wxPyBeginAllowThreads();
36084 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36085 wxPyEndAllowThreads(__tstate);
36086 if (PyErr_Occurred()) SWIG_fail;
36087 }
36088 {
36089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36090 }
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 long arg2 ;
36101 void *argp1 = 0 ;
36102 int res1 = 0 ;
36103 long val2 ;
36104 int ecode2 = 0 ;
36105 PyObject * obj0 = 0 ;
36106 PyObject * obj1 = 0 ;
36107 char * kwnames[] = {
36108 (char *) "self",(char *) "exStyle", NULL
36109 };
36110
36111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36113 if (!SWIG_IsOK(res1)) {
36114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36115 }
36116 arg1 = reinterpret_cast< wxWindow * >(argp1);
36117 ecode2 = SWIG_AsVal_long(obj1, &val2);
36118 if (!SWIG_IsOK(ecode2)) {
36119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36120 }
36121 arg2 = static_cast< long >(val2);
36122 {
36123 PyThreadState* __tstate = wxPyBeginAllowThreads();
36124 (arg1)->SetExtraStyle(arg2);
36125 wxPyEndAllowThreads(__tstate);
36126 if (PyErr_Occurred()) SWIG_fail;
36127 }
36128 resultobj = SWIG_Py_Void();
36129 return resultobj;
36130 fail:
36131 return NULL;
36132 }
36133
36134
36135 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36136 PyObject *resultobj = 0;
36137 wxWindow *arg1 = (wxWindow *) 0 ;
36138 long result;
36139 void *argp1 = 0 ;
36140 int res1 = 0 ;
36141 PyObject *swig_obj[1] ;
36142
36143 if (!args) SWIG_fail;
36144 swig_obj[0] = args;
36145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36146 if (!SWIG_IsOK(res1)) {
36147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36148 }
36149 arg1 = reinterpret_cast< wxWindow * >(argp1);
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36153 wxPyEndAllowThreads(__tstate);
36154 if (PyErr_Occurred()) SWIG_fail;
36155 }
36156 resultobj = SWIG_From_long(static_cast< long >(result));
36157 return resultobj;
36158 fail:
36159 return NULL;
36160 }
36161
36162
36163 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36164 PyObject *resultobj = 0;
36165 wxWindow *arg1 = (wxWindow *) 0 ;
36166 bool arg2 = (bool) true ;
36167 void *argp1 = 0 ;
36168 int res1 = 0 ;
36169 bool val2 ;
36170 int ecode2 = 0 ;
36171 PyObject * obj0 = 0 ;
36172 PyObject * obj1 = 0 ;
36173 char * kwnames[] = {
36174 (char *) "self",(char *) "modal", NULL
36175 };
36176
36177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36179 if (!SWIG_IsOK(res1)) {
36180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36181 }
36182 arg1 = reinterpret_cast< wxWindow * >(argp1);
36183 if (obj1) {
36184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36185 if (!SWIG_IsOK(ecode2)) {
36186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36187 }
36188 arg2 = static_cast< bool >(val2);
36189 }
36190 {
36191 PyThreadState* __tstate = wxPyBeginAllowThreads();
36192 (arg1)->MakeModal(arg2);
36193 wxPyEndAllowThreads(__tstate);
36194 if (PyErr_Occurred()) SWIG_fail;
36195 }
36196 resultobj = SWIG_Py_Void();
36197 return resultobj;
36198 fail:
36199 return NULL;
36200 }
36201
36202
36203 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36204 PyObject *resultobj = 0;
36205 wxWindow *arg1 = (wxWindow *) 0 ;
36206 bool arg2 ;
36207 void *argp1 = 0 ;
36208 int res1 = 0 ;
36209 bool val2 ;
36210 int ecode2 = 0 ;
36211 PyObject * obj0 = 0 ;
36212 PyObject * obj1 = 0 ;
36213 char * kwnames[] = {
36214 (char *) "self",(char *) "enableTheme", NULL
36215 };
36216
36217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36219 if (!SWIG_IsOK(res1)) {
36220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36221 }
36222 arg1 = reinterpret_cast< wxWindow * >(argp1);
36223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36224 if (!SWIG_IsOK(ecode2)) {
36225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36226 }
36227 arg2 = static_cast< bool >(val2);
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 (arg1)->SetThemeEnabled(arg2);
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 resultobj = SWIG_Py_Void();
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 bool result;
36245 void *argp1 = 0 ;
36246 int res1 = 0 ;
36247 PyObject *swig_obj[1] ;
36248
36249 if (!args) SWIG_fail;
36250 swig_obj[0] = args;
36251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36252 if (!SWIG_IsOK(res1)) {
36253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36254 }
36255 arg1 = reinterpret_cast< wxWindow * >(argp1);
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 {
36263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36264 }
36265 return resultobj;
36266 fail:
36267 return NULL;
36268 }
36269
36270
36271 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36272 PyObject *resultobj = 0;
36273 wxWindow *arg1 = (wxWindow *) 0 ;
36274 void *argp1 = 0 ;
36275 int res1 = 0 ;
36276 PyObject *swig_obj[1] ;
36277
36278 if (!args) SWIG_fail;
36279 swig_obj[0] = args;
36280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36281 if (!SWIG_IsOK(res1)) {
36282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36283 }
36284 arg1 = reinterpret_cast< wxWindow * >(argp1);
36285 {
36286 PyThreadState* __tstate = wxPyBeginAllowThreads();
36287 (arg1)->SetFocus();
36288 wxPyEndAllowThreads(__tstate);
36289 if (PyErr_Occurred()) SWIG_fail;
36290 }
36291 resultobj = SWIG_Py_Void();
36292 return resultobj;
36293 fail:
36294 return NULL;
36295 }
36296
36297
36298 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36299 PyObject *resultobj = 0;
36300 wxWindow *arg1 = (wxWindow *) 0 ;
36301 void *argp1 = 0 ;
36302 int res1 = 0 ;
36303 PyObject *swig_obj[1] ;
36304
36305 if (!args) SWIG_fail;
36306 swig_obj[0] = args;
36307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36308 if (!SWIG_IsOK(res1)) {
36309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36310 }
36311 arg1 = reinterpret_cast< wxWindow * >(argp1);
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 (arg1)->SetFocusFromKbd();
36315 wxPyEndAllowThreads(__tstate);
36316 if (PyErr_Occurred()) SWIG_fail;
36317 }
36318 resultobj = SWIG_Py_Void();
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36326 PyObject *resultobj = 0;
36327 wxWindow *result = 0 ;
36328
36329 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36330 {
36331 if (!wxPyCheckForApp()) SWIG_fail;
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (wxWindow *)wxWindow::FindFocus();
36334 wxPyEndAllowThreads(__tstate);
36335 if (PyErr_Occurred()) SWIG_fail;
36336 }
36337 {
36338 resultobj = wxPyMake_wxObject(result, 0);
36339 }
36340 return resultobj;
36341 fail:
36342 return NULL;
36343 }
36344
36345
36346 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36347 PyObject *resultobj = 0;
36348 wxWindow *arg1 = (wxWindow *) 0 ;
36349 bool result;
36350 void *argp1 = 0 ;
36351 int res1 = 0 ;
36352 PyObject *swig_obj[1] ;
36353
36354 if (!args) SWIG_fail;
36355 swig_obj[0] = args;
36356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 {
36362 PyThreadState* __tstate = wxPyBeginAllowThreads();
36363 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36364 wxPyEndAllowThreads(__tstate);
36365 if (PyErr_Occurred()) SWIG_fail;
36366 }
36367 {
36368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36369 }
36370 return resultobj;
36371 fail:
36372 return NULL;
36373 }
36374
36375
36376 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36377 PyObject *resultobj = 0;
36378 wxWindow *arg1 = (wxWindow *) 0 ;
36379 bool result;
36380 void *argp1 = 0 ;
36381 int res1 = 0 ;
36382 PyObject *swig_obj[1] ;
36383
36384 if (!args) SWIG_fail;
36385 swig_obj[0] = args;
36386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36387 if (!SWIG_IsOK(res1)) {
36388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36389 }
36390 arg1 = reinterpret_cast< wxWindow * >(argp1);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 {
36398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36399 }
36400 return resultobj;
36401 fail:
36402 return NULL;
36403 }
36404
36405
36406 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36407 PyObject *resultobj = 0;
36408 wxWindow *arg1 = (wxWindow *) 0 ;
36409 bool result;
36410 void *argp1 = 0 ;
36411 int res1 = 0 ;
36412 PyObject *swig_obj[1] ;
36413
36414 if (!args) SWIG_fail;
36415 swig_obj[0] = args;
36416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36417 if (!SWIG_IsOK(res1)) {
36418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36419 }
36420 arg1 = reinterpret_cast< wxWindow * >(argp1);
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 {
36428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36429 }
36430 return resultobj;
36431 fail:
36432 return NULL;
36433 }
36434
36435
36436 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36437 PyObject *resultobj = 0;
36438 wxWindow *arg1 = (wxWindow *) 0 ;
36439 bool result;
36440 void *argp1 = 0 ;
36441 int res1 = 0 ;
36442 PyObject *swig_obj[1] ;
36443
36444 if (!args) SWIG_fail;
36445 swig_obj[0] = args;
36446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36447 if (!SWIG_IsOK(res1)) {
36448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36449 }
36450 arg1 = reinterpret_cast< wxWindow * >(argp1);
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 {
36458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36459 }
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36467 PyObject *resultobj = 0;
36468 wxWindow *arg1 = (wxWindow *) 0 ;
36469 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36470 bool result;
36471 void *argp1 = 0 ;
36472 int res1 = 0 ;
36473 int val2 ;
36474 int ecode2 = 0 ;
36475 PyObject * obj0 = 0 ;
36476 PyObject * obj1 = 0 ;
36477 char * kwnames[] = {
36478 (char *) "self",(char *) "flags", NULL
36479 };
36480
36481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36483 if (!SWIG_IsOK(res1)) {
36484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36485 }
36486 arg1 = reinterpret_cast< wxWindow * >(argp1);
36487 if (obj1) {
36488 ecode2 = SWIG_AsVal_int(obj1, &val2);
36489 if (!SWIG_IsOK(ecode2)) {
36490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36491 }
36492 arg2 = static_cast< int >(val2);
36493 }
36494 {
36495 PyThreadState* __tstate = wxPyBeginAllowThreads();
36496 result = (bool)(arg1)->NavigateIn(arg2);
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 {
36501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36502 }
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj = 0;
36511 wxWindow *arg1 = (wxWindow *) 0 ;
36512 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36513 bool result;
36514 void *argp1 = 0 ;
36515 int res1 = 0 ;
36516 int val2 ;
36517 int ecode2 = 0 ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char * kwnames[] = {
36521 (char *) "self",(char *) "flags", NULL
36522 };
36523
36524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36526 if (!SWIG_IsOK(res1)) {
36527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36528 }
36529 arg1 = reinterpret_cast< wxWindow * >(argp1);
36530 if (obj1) {
36531 ecode2 = SWIG_AsVal_int(obj1, &val2);
36532 if (!SWIG_IsOK(ecode2)) {
36533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36534 }
36535 arg2 = static_cast< int >(val2);
36536 }
36537 {
36538 PyThreadState* __tstate = wxPyBeginAllowThreads();
36539 result = (bool)(arg1)->Navigate(arg2);
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 {
36544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36545 }
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj = 0;
36554 wxWindow *arg1 = (wxWindow *) 0 ;
36555 wxWindow *arg2 = (wxWindow *) 0 ;
36556 void *argp1 = 0 ;
36557 int res1 = 0 ;
36558 void *argp2 = 0 ;
36559 int res2 = 0 ;
36560 PyObject * obj0 = 0 ;
36561 PyObject * obj1 = 0 ;
36562 char * kwnames[] = {
36563 (char *) "self",(char *) "win", NULL
36564 };
36565
36566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36568 if (!SWIG_IsOK(res1)) {
36569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36570 }
36571 arg1 = reinterpret_cast< wxWindow * >(argp1);
36572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36573 if (!SWIG_IsOK(res2)) {
36574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36575 }
36576 arg2 = reinterpret_cast< wxWindow * >(argp2);
36577 {
36578 PyThreadState* __tstate = wxPyBeginAllowThreads();
36579 (arg1)->MoveAfterInTabOrder(arg2);
36580 wxPyEndAllowThreads(__tstate);
36581 if (PyErr_Occurred()) SWIG_fail;
36582 }
36583 resultobj = SWIG_Py_Void();
36584 return resultobj;
36585 fail:
36586 return NULL;
36587 }
36588
36589
36590 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36591 PyObject *resultobj = 0;
36592 wxWindow *arg1 = (wxWindow *) 0 ;
36593 wxWindow *arg2 = (wxWindow *) 0 ;
36594 void *argp1 = 0 ;
36595 int res1 = 0 ;
36596 void *argp2 = 0 ;
36597 int res2 = 0 ;
36598 PyObject * obj0 = 0 ;
36599 PyObject * obj1 = 0 ;
36600 char * kwnames[] = {
36601 (char *) "self",(char *) "win", NULL
36602 };
36603
36604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36608 }
36609 arg1 = reinterpret_cast< wxWindow * >(argp1);
36610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36611 if (!SWIG_IsOK(res2)) {
36612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36613 }
36614 arg2 = reinterpret_cast< wxWindow * >(argp2);
36615 {
36616 PyThreadState* __tstate = wxPyBeginAllowThreads();
36617 (arg1)->MoveBeforeInTabOrder(arg2);
36618 wxPyEndAllowThreads(__tstate);
36619 if (PyErr_Occurred()) SWIG_fail;
36620 }
36621 resultobj = SWIG_Py_Void();
36622 return resultobj;
36623 fail:
36624 return NULL;
36625 }
36626
36627
36628 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36629 PyObject *resultobj = 0;
36630 wxWindow *arg1 = (wxWindow *) 0 ;
36631 PyObject *result = 0 ;
36632 void *argp1 = 0 ;
36633 int res1 = 0 ;
36634 PyObject *swig_obj[1] ;
36635
36636 if (!args) SWIG_fail;
36637 swig_obj[0] = args;
36638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36639 if (!SWIG_IsOK(res1)) {
36640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36641 }
36642 arg1 = reinterpret_cast< wxWindow * >(argp1);
36643 {
36644 PyThreadState* __tstate = wxPyBeginAllowThreads();
36645 result = (PyObject *)wxWindow_GetChildren(arg1);
36646 wxPyEndAllowThreads(__tstate);
36647 if (PyErr_Occurred()) SWIG_fail;
36648 }
36649 resultobj = result;
36650 return resultobj;
36651 fail:
36652 return NULL;
36653 }
36654
36655
36656 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36657 PyObject *resultobj = 0;
36658 wxWindow *arg1 = (wxWindow *) 0 ;
36659 wxWindow *result = 0 ;
36660 void *argp1 = 0 ;
36661 int res1 = 0 ;
36662 PyObject *swig_obj[1] ;
36663
36664 if (!args) SWIG_fail;
36665 swig_obj[0] = args;
36666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36669 }
36670 arg1 = reinterpret_cast< wxWindow * >(argp1);
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 {
36678 resultobj = wxPyMake_wxObject(result, 0);
36679 }
36680 return resultobj;
36681 fail:
36682 return NULL;
36683 }
36684
36685
36686 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36687 PyObject *resultobj = 0;
36688 wxWindow *arg1 = (wxWindow *) 0 ;
36689 wxWindow *result = 0 ;
36690 void *argp1 = 0 ;
36691 int res1 = 0 ;
36692 PyObject *swig_obj[1] ;
36693
36694 if (!args) SWIG_fail;
36695 swig_obj[0] = args;
36696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36697 if (!SWIG_IsOK(res1)) {
36698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36699 }
36700 arg1 = reinterpret_cast< wxWindow * >(argp1);
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36704 wxPyEndAllowThreads(__tstate);
36705 if (PyErr_Occurred()) SWIG_fail;
36706 }
36707 {
36708 resultobj = wxPyMake_wxObject(result, 0);
36709 }
36710 return resultobj;
36711 fail:
36712 return NULL;
36713 }
36714
36715
36716 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36717 PyObject *resultobj = 0;
36718 wxWindow *arg1 = (wxWindow *) 0 ;
36719 wxWindow *result = 0 ;
36720 void *argp1 = 0 ;
36721 int res1 = 0 ;
36722 PyObject *swig_obj[1] ;
36723
36724 if (!args) SWIG_fail;
36725 swig_obj[0] = args;
36726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36727 if (!SWIG_IsOK(res1)) {
36728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
36729 }
36730 arg1 = reinterpret_cast< wxWindow * >(argp1);
36731 {
36732 PyThreadState* __tstate = wxPyBeginAllowThreads();
36733 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 {
36738 resultobj = wxPyMake_wxObject(result, 0);
36739 }
36740 return resultobj;
36741 fail:
36742 return NULL;
36743 }
36744
36745
36746 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36747 PyObject *resultobj = 0;
36748 wxWindow *arg1 = (wxWindow *) 0 ;
36749 bool result;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 PyObject *swig_obj[1] ;
36753
36754 if (!args) SWIG_fail;
36755 swig_obj[0] = args;
36756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36757 if (!SWIG_IsOK(res1)) {
36758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36759 }
36760 arg1 = reinterpret_cast< wxWindow * >(argp1);
36761 {
36762 PyThreadState* __tstate = wxPyBeginAllowThreads();
36763 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36764 wxPyEndAllowThreads(__tstate);
36765 if (PyErr_Occurred()) SWIG_fail;
36766 }
36767 {
36768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36769 }
36770 return resultobj;
36771 fail:
36772 return NULL;
36773 }
36774
36775
36776 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36777 PyObject *resultobj = 0;
36778 wxWindow *arg1 = (wxWindow *) 0 ;
36779 wxWindow *arg2 = (wxWindow *) 0 ;
36780 bool result;
36781 void *argp1 = 0 ;
36782 int res1 = 0 ;
36783 void *argp2 = 0 ;
36784 int res2 = 0 ;
36785 PyObject * obj0 = 0 ;
36786 PyObject * obj1 = 0 ;
36787 char * kwnames[] = {
36788 (char *) "self",(char *) "newParent", NULL
36789 };
36790
36791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36793 if (!SWIG_IsOK(res1)) {
36794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36795 }
36796 arg1 = reinterpret_cast< wxWindow * >(argp1);
36797 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36798 if (!SWIG_IsOK(res2)) {
36799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36800 }
36801 arg2 = reinterpret_cast< wxWindow * >(argp2);
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 result = (bool)(arg1)->Reparent(arg2);
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 {
36809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36810 }
36811 return resultobj;
36812 fail:
36813 return NULL;
36814 }
36815
36816
36817 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36818 PyObject *resultobj = 0;
36819 wxWindow *arg1 = (wxWindow *) 0 ;
36820 wxWindow *arg2 = (wxWindow *) 0 ;
36821 void *argp1 = 0 ;
36822 int res1 = 0 ;
36823 void *argp2 = 0 ;
36824 int res2 = 0 ;
36825 PyObject * obj0 = 0 ;
36826 PyObject * obj1 = 0 ;
36827 char * kwnames[] = {
36828 (char *) "self",(char *) "child", NULL
36829 };
36830
36831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36833 if (!SWIG_IsOK(res1)) {
36834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36835 }
36836 arg1 = reinterpret_cast< wxWindow * >(argp1);
36837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36838 if (!SWIG_IsOK(res2)) {
36839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36840 }
36841 arg2 = reinterpret_cast< wxWindow * >(argp2);
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 (arg1)->AddChild(arg2);
36845 wxPyEndAllowThreads(__tstate);
36846 if (PyErr_Occurred()) SWIG_fail;
36847 }
36848 resultobj = SWIG_Py_Void();
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36856 PyObject *resultobj = 0;
36857 wxWindow *arg1 = (wxWindow *) 0 ;
36858 wxWindow *arg2 = (wxWindow *) 0 ;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 void *argp2 = 0 ;
36862 int res2 = 0 ;
36863 PyObject * obj0 = 0 ;
36864 PyObject * obj1 = 0 ;
36865 char * kwnames[] = {
36866 (char *) "self",(char *) "child", NULL
36867 };
36868
36869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36871 if (!SWIG_IsOK(res1)) {
36872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36873 }
36874 arg1 = reinterpret_cast< wxWindow * >(argp1);
36875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36876 if (!SWIG_IsOK(res2)) {
36877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36878 }
36879 arg2 = reinterpret_cast< wxWindow * >(argp2);
36880 {
36881 PyThreadState* __tstate = wxPyBeginAllowThreads();
36882 (arg1)->RemoveChild(arg2);
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 resultobj = SWIG_Py_Void();
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36894 PyObject *resultobj = 0;
36895 wxWindow *arg1 = (wxWindow *) 0 ;
36896 bool arg2 ;
36897 void *argp1 = 0 ;
36898 int res1 = 0 ;
36899 bool val2 ;
36900 int ecode2 = 0 ;
36901 PyObject * obj0 = 0 ;
36902 PyObject * obj1 = 0 ;
36903 char * kwnames[] = {
36904 (char *) "self",(char *) "on", NULL
36905 };
36906
36907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36909 if (!SWIG_IsOK(res1)) {
36910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36911 }
36912 arg1 = reinterpret_cast< wxWindow * >(argp1);
36913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36914 if (!SWIG_IsOK(ecode2)) {
36915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36916 }
36917 arg2 = static_cast< bool >(val2);
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 wxWindow_SetDoubleBuffered(arg1,arg2);
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 resultobj = SWIG_Py_Void();
36925 return resultobj;
36926 fail:
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36932 PyObject *resultobj = 0;
36933 wxWindow *arg1 = (wxWindow *) 0 ;
36934 long arg2 ;
36935 wxWindow *result = 0 ;
36936 void *argp1 = 0 ;
36937 int res1 = 0 ;
36938 long val2 ;
36939 int ecode2 = 0 ;
36940 PyObject * obj0 = 0 ;
36941 PyObject * obj1 = 0 ;
36942 char * kwnames[] = {
36943 (char *) "self",(char *) "winid", NULL
36944 };
36945
36946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36948 if (!SWIG_IsOK(res1)) {
36949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36950 }
36951 arg1 = reinterpret_cast< wxWindow * >(argp1);
36952 ecode2 = SWIG_AsVal_long(obj1, &val2);
36953 if (!SWIG_IsOK(ecode2)) {
36954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36955 }
36956 arg2 = static_cast< long >(val2);
36957 {
36958 PyThreadState* __tstate = wxPyBeginAllowThreads();
36959 result = (wxWindow *)(arg1)->FindWindow(arg2);
36960 wxPyEndAllowThreads(__tstate);
36961 if (PyErr_Occurred()) SWIG_fail;
36962 }
36963 {
36964 resultobj = wxPyMake_wxObject(result, 0);
36965 }
36966 return resultobj;
36967 fail:
36968 return NULL;
36969 }
36970
36971
36972 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36973 PyObject *resultobj = 0;
36974 wxWindow *arg1 = (wxWindow *) 0 ;
36975 wxString *arg2 = 0 ;
36976 wxWindow *result = 0 ;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 bool temp2 = false ;
36980 PyObject * obj0 = 0 ;
36981 PyObject * obj1 = 0 ;
36982 char * kwnames[] = {
36983 (char *) "self",(char *) "name", NULL
36984 };
36985
36986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36988 if (!SWIG_IsOK(res1)) {
36989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36990 }
36991 arg1 = reinterpret_cast< wxWindow * >(argp1);
36992 {
36993 arg2 = wxString_in_helper(obj1);
36994 if (arg2 == NULL) SWIG_fail;
36995 temp2 = true;
36996 }
36997 {
36998 PyThreadState* __tstate = wxPyBeginAllowThreads();
36999 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37000 wxPyEndAllowThreads(__tstate);
37001 if (PyErr_Occurred()) SWIG_fail;
37002 }
37003 {
37004 resultobj = wxPyMake_wxObject(result, 0);
37005 }
37006 {
37007 if (temp2)
37008 delete arg2;
37009 }
37010 return resultobj;
37011 fail:
37012 {
37013 if (temp2)
37014 delete arg2;
37015 }
37016 return NULL;
37017 }
37018
37019
37020 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37021 PyObject *resultobj = 0;
37022 wxWindow *arg1 = (wxWindow *) 0 ;
37023 wxEvtHandler *result = 0 ;
37024 void *argp1 = 0 ;
37025 int res1 = 0 ;
37026 PyObject *swig_obj[1] ;
37027
37028 if (!args) SWIG_fail;
37029 swig_obj[0] = args;
37030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37031 if (!SWIG_IsOK(res1)) {
37032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37033 }
37034 arg1 = reinterpret_cast< wxWindow * >(argp1);
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37038 wxPyEndAllowThreads(__tstate);
37039 if (PyErr_Occurred()) SWIG_fail;
37040 }
37041 {
37042 resultobj = wxPyMake_wxObject(result, 0);
37043 }
37044 return resultobj;
37045 fail:
37046 return NULL;
37047 }
37048
37049
37050 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37051 PyObject *resultobj = 0;
37052 wxWindow *arg1 = (wxWindow *) 0 ;
37053 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37054 void *argp1 = 0 ;
37055 int res1 = 0 ;
37056 void *argp2 = 0 ;
37057 int res2 = 0 ;
37058 PyObject * obj0 = 0 ;
37059 PyObject * obj1 = 0 ;
37060 char * kwnames[] = {
37061 (char *) "self",(char *) "handler", NULL
37062 };
37063
37064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37066 if (!SWIG_IsOK(res1)) {
37067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37068 }
37069 arg1 = reinterpret_cast< wxWindow * >(argp1);
37070 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37071 if (!SWIG_IsOK(res2)) {
37072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37073 }
37074 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37075 {
37076 PyThreadState* __tstate = wxPyBeginAllowThreads();
37077 (arg1)->SetEventHandler(arg2);
37078 wxPyEndAllowThreads(__tstate);
37079 if (PyErr_Occurred()) SWIG_fail;
37080 }
37081 resultobj = SWIG_Py_Void();
37082 return resultobj;
37083 fail:
37084 return NULL;
37085 }
37086
37087
37088 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37089 PyObject *resultobj = 0;
37090 wxWindow *arg1 = (wxWindow *) 0 ;
37091 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37092 void *argp1 = 0 ;
37093 int res1 = 0 ;
37094 void *argp2 = 0 ;
37095 int res2 = 0 ;
37096 PyObject * obj0 = 0 ;
37097 PyObject * obj1 = 0 ;
37098 char * kwnames[] = {
37099 (char *) "self",(char *) "handler", NULL
37100 };
37101
37102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37104 if (!SWIG_IsOK(res1)) {
37105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37106 }
37107 arg1 = reinterpret_cast< wxWindow * >(argp1);
37108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37109 if (!SWIG_IsOK(res2)) {
37110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37111 }
37112 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37113 {
37114 PyThreadState* __tstate = wxPyBeginAllowThreads();
37115 (arg1)->PushEventHandler(arg2);
37116 wxPyEndAllowThreads(__tstate);
37117 if (PyErr_Occurred()) SWIG_fail;
37118 }
37119 resultobj = SWIG_Py_Void();
37120 return resultobj;
37121 fail:
37122 return NULL;
37123 }
37124
37125
37126 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37127 PyObject *resultobj = 0;
37128 wxWindow *arg1 = (wxWindow *) 0 ;
37129 bool arg2 = (bool) false ;
37130 wxEvtHandler *result = 0 ;
37131 void *argp1 = 0 ;
37132 int res1 = 0 ;
37133 bool val2 ;
37134 int ecode2 = 0 ;
37135 PyObject * obj0 = 0 ;
37136 PyObject * obj1 = 0 ;
37137 char * kwnames[] = {
37138 (char *) "self",(char *) "deleteHandler", NULL
37139 };
37140
37141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37143 if (!SWIG_IsOK(res1)) {
37144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37145 }
37146 arg1 = reinterpret_cast< wxWindow * >(argp1);
37147 if (obj1) {
37148 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37149 if (!SWIG_IsOK(ecode2)) {
37150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37151 }
37152 arg2 = static_cast< bool >(val2);
37153 }
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 {
37161 resultobj = wxPyMake_wxObject(result, 0);
37162 }
37163 return resultobj;
37164 fail:
37165 return NULL;
37166 }
37167
37168
37169 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37170 PyObject *resultobj = 0;
37171 wxWindow *arg1 = (wxWindow *) 0 ;
37172 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37173 bool result;
37174 void *argp1 = 0 ;
37175 int res1 = 0 ;
37176 void *argp2 = 0 ;
37177 int res2 = 0 ;
37178 PyObject * obj0 = 0 ;
37179 PyObject * obj1 = 0 ;
37180 char * kwnames[] = {
37181 (char *) "self",(char *) "handler", NULL
37182 };
37183
37184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37186 if (!SWIG_IsOK(res1)) {
37187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37188 }
37189 arg1 = reinterpret_cast< wxWindow * >(argp1);
37190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37191 if (!SWIG_IsOK(res2)) {
37192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37193 }
37194 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37195 {
37196 PyThreadState* __tstate = wxPyBeginAllowThreads();
37197 result = (bool)(arg1)->RemoveEventHandler(arg2);
37198 wxPyEndAllowThreads(__tstate);
37199 if (PyErr_Occurred()) SWIG_fail;
37200 }
37201 {
37202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37203 }
37204 return resultobj;
37205 fail:
37206 return NULL;
37207 }
37208
37209
37210 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37211 PyObject *resultobj = 0;
37212 wxWindow *arg1 = (wxWindow *) 0 ;
37213 wxValidator *arg2 = 0 ;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 void *argp2 = 0 ;
37217 int res2 = 0 ;
37218 PyObject * obj0 = 0 ;
37219 PyObject * obj1 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "self",(char *) "validator", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37226 if (!SWIG_IsOK(res1)) {
37227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37228 }
37229 arg1 = reinterpret_cast< wxWindow * >(argp1);
37230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37231 if (!SWIG_IsOK(res2)) {
37232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37233 }
37234 if (!argp2) {
37235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37236 }
37237 arg2 = reinterpret_cast< wxValidator * >(argp2);
37238 {
37239 PyThreadState* __tstate = wxPyBeginAllowThreads();
37240 (arg1)->SetValidator((wxValidator const &)*arg2);
37241 wxPyEndAllowThreads(__tstate);
37242 if (PyErr_Occurred()) SWIG_fail;
37243 }
37244 resultobj = SWIG_Py_Void();
37245 return resultobj;
37246 fail:
37247 return NULL;
37248 }
37249
37250
37251 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37252 PyObject *resultobj = 0;
37253 wxWindow *arg1 = (wxWindow *) 0 ;
37254 wxValidator *result = 0 ;
37255 void *argp1 = 0 ;
37256 int res1 = 0 ;
37257 PyObject *swig_obj[1] ;
37258
37259 if (!args) SWIG_fail;
37260 swig_obj[0] = args;
37261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37262 if (!SWIG_IsOK(res1)) {
37263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37264 }
37265 arg1 = reinterpret_cast< wxWindow * >(argp1);
37266 {
37267 PyThreadState* __tstate = wxPyBeginAllowThreads();
37268 result = (wxValidator *)(arg1)->GetValidator();
37269 wxPyEndAllowThreads(__tstate);
37270 if (PyErr_Occurred()) SWIG_fail;
37271 }
37272 {
37273 resultobj = wxPyMake_wxObject(result, (bool)0);
37274 }
37275 return resultobj;
37276 fail:
37277 return NULL;
37278 }
37279
37280
37281 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37282 PyObject *resultobj = 0;
37283 wxWindow *arg1 = (wxWindow *) 0 ;
37284 bool result;
37285 void *argp1 = 0 ;
37286 int res1 = 0 ;
37287 PyObject *swig_obj[1] ;
37288
37289 if (!args) SWIG_fail;
37290 swig_obj[0] = args;
37291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37292 if (!SWIG_IsOK(res1)) {
37293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37294 }
37295 arg1 = reinterpret_cast< wxWindow * >(argp1);
37296 {
37297 PyThreadState* __tstate = wxPyBeginAllowThreads();
37298 result = (bool)(arg1)->Validate();
37299 wxPyEndAllowThreads(__tstate);
37300 if (PyErr_Occurred()) SWIG_fail;
37301 }
37302 {
37303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37304 }
37305 return resultobj;
37306 fail:
37307 return NULL;
37308 }
37309
37310
37311 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37312 PyObject *resultobj = 0;
37313 wxWindow *arg1 = (wxWindow *) 0 ;
37314 bool result;
37315 void *argp1 = 0 ;
37316 int res1 = 0 ;
37317 PyObject *swig_obj[1] ;
37318
37319 if (!args) SWIG_fail;
37320 swig_obj[0] = args;
37321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37322 if (!SWIG_IsOK(res1)) {
37323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37324 }
37325 arg1 = reinterpret_cast< wxWindow * >(argp1);
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 result = (bool)(arg1)->TransferDataToWindow();
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 {
37333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37334 }
37335 return resultobj;
37336 fail:
37337 return NULL;
37338 }
37339
37340
37341 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37342 PyObject *resultobj = 0;
37343 wxWindow *arg1 = (wxWindow *) 0 ;
37344 bool result;
37345 void *argp1 = 0 ;
37346 int res1 = 0 ;
37347 PyObject *swig_obj[1] ;
37348
37349 if (!args) SWIG_fail;
37350 swig_obj[0] = args;
37351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37352 if (!SWIG_IsOK(res1)) {
37353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37354 }
37355 arg1 = reinterpret_cast< wxWindow * >(argp1);
37356 {
37357 PyThreadState* __tstate = wxPyBeginAllowThreads();
37358 result = (bool)(arg1)->TransferDataFromWindow();
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 {
37363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37364 }
37365 return resultobj;
37366 fail:
37367 return NULL;
37368 }
37369
37370
37371 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37372 PyObject *resultobj = 0;
37373 wxWindow *arg1 = (wxWindow *) 0 ;
37374 void *argp1 = 0 ;
37375 int res1 = 0 ;
37376 PyObject *swig_obj[1] ;
37377
37378 if (!args) SWIG_fail;
37379 swig_obj[0] = args;
37380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37381 if (!SWIG_IsOK(res1)) {
37382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37383 }
37384 arg1 = reinterpret_cast< wxWindow * >(argp1);
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 (arg1)->InitDialog();
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 resultobj = SWIG_Py_Void();
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37399 PyObject *resultobj = 0;
37400 wxWindow *arg1 = (wxWindow *) 0 ;
37401 wxAcceleratorTable *arg2 = 0 ;
37402 void *argp1 = 0 ;
37403 int res1 = 0 ;
37404 void *argp2 = 0 ;
37405 int res2 = 0 ;
37406 PyObject * obj0 = 0 ;
37407 PyObject * obj1 = 0 ;
37408 char * kwnames[] = {
37409 (char *) "self",(char *) "accel", NULL
37410 };
37411
37412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37414 if (!SWIG_IsOK(res1)) {
37415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37416 }
37417 arg1 = reinterpret_cast< wxWindow * >(argp1);
37418 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37419 if (!SWIG_IsOK(res2)) {
37420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37421 }
37422 if (!argp2) {
37423 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37424 }
37425 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37426 {
37427 PyThreadState* __tstate = wxPyBeginAllowThreads();
37428 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37429 wxPyEndAllowThreads(__tstate);
37430 if (PyErr_Occurred()) SWIG_fail;
37431 }
37432 resultobj = SWIG_Py_Void();
37433 return resultobj;
37434 fail:
37435 return NULL;
37436 }
37437
37438
37439 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37440 PyObject *resultobj = 0;
37441 wxWindow *arg1 = (wxWindow *) 0 ;
37442 wxAcceleratorTable *result = 0 ;
37443 void *argp1 = 0 ;
37444 int res1 = 0 ;
37445 PyObject *swig_obj[1] ;
37446
37447 if (!args) SWIG_fail;
37448 swig_obj[0] = args;
37449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37450 if (!SWIG_IsOK(res1)) {
37451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37452 }
37453 arg1 = reinterpret_cast< wxWindow * >(argp1);
37454 {
37455 PyThreadState* __tstate = wxPyBeginAllowThreads();
37456 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37457 wxPyEndAllowThreads(__tstate);
37458 if (PyErr_Occurred()) SWIG_fail;
37459 }
37460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37461 return resultobj;
37462 fail:
37463 return NULL;
37464 }
37465
37466
37467 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37468 PyObject *resultobj = 0;
37469 wxWindow *arg1 = (wxWindow *) 0 ;
37470 int arg2 ;
37471 int arg3 ;
37472 int arg4 ;
37473 bool result;
37474 void *argp1 = 0 ;
37475 int res1 = 0 ;
37476 int val2 ;
37477 int ecode2 = 0 ;
37478 int val3 ;
37479 int ecode3 = 0 ;
37480 int val4 ;
37481 int ecode4 = 0 ;
37482 PyObject * obj0 = 0 ;
37483 PyObject * obj1 = 0 ;
37484 PyObject * obj2 = 0 ;
37485 PyObject * obj3 = 0 ;
37486 char * kwnames[] = {
37487 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37488 };
37489
37490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37492 if (!SWIG_IsOK(res1)) {
37493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37494 }
37495 arg1 = reinterpret_cast< wxWindow * >(argp1);
37496 ecode2 = SWIG_AsVal_int(obj1, &val2);
37497 if (!SWIG_IsOK(ecode2)) {
37498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37499 }
37500 arg2 = static_cast< int >(val2);
37501 ecode3 = SWIG_AsVal_int(obj2, &val3);
37502 if (!SWIG_IsOK(ecode3)) {
37503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37504 }
37505 arg3 = static_cast< int >(val3);
37506 ecode4 = SWIG_AsVal_int(obj3, &val4);
37507 if (!SWIG_IsOK(ecode4)) {
37508 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37509 }
37510 arg4 = static_cast< int >(val4);
37511 {
37512 PyThreadState* __tstate = wxPyBeginAllowThreads();
37513 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37514 wxPyEndAllowThreads(__tstate);
37515 if (PyErr_Occurred()) SWIG_fail;
37516 }
37517 {
37518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37519 }
37520 return resultobj;
37521 fail:
37522 return NULL;
37523 }
37524
37525
37526 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37527 PyObject *resultobj = 0;
37528 wxWindow *arg1 = (wxWindow *) 0 ;
37529 int arg2 ;
37530 bool result;
37531 void *argp1 = 0 ;
37532 int res1 = 0 ;
37533 int val2 ;
37534 int ecode2 = 0 ;
37535 PyObject * obj0 = 0 ;
37536 PyObject * obj1 = 0 ;
37537 char * kwnames[] = {
37538 (char *) "self",(char *) "hotkeyId", NULL
37539 };
37540
37541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37543 if (!SWIG_IsOK(res1)) {
37544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37545 }
37546 arg1 = reinterpret_cast< wxWindow * >(argp1);
37547 ecode2 = SWIG_AsVal_int(obj1, &val2);
37548 if (!SWIG_IsOK(ecode2)) {
37549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37550 }
37551 arg2 = static_cast< int >(val2);
37552 {
37553 PyThreadState* __tstate = wxPyBeginAllowThreads();
37554 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37555 wxPyEndAllowThreads(__tstate);
37556 if (PyErr_Occurred()) SWIG_fail;
37557 }
37558 {
37559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37560 }
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37568 PyObject *resultobj = 0;
37569 wxWindow *arg1 = (wxWindow *) 0 ;
37570 wxPoint *arg2 = 0 ;
37571 wxPoint result;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 wxPoint temp2 ;
37575 PyObject * obj0 = 0 ;
37576 PyObject * obj1 = 0 ;
37577 char * kwnames[] = {
37578 (char *) "self",(char *) "pt", NULL
37579 };
37580
37581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37583 if (!SWIG_IsOK(res1)) {
37584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37585 }
37586 arg1 = reinterpret_cast< wxWindow * >(argp1);
37587 {
37588 arg2 = &temp2;
37589 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37590 }
37591 {
37592 PyThreadState* __tstate = wxPyBeginAllowThreads();
37593 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37594 wxPyEndAllowThreads(__tstate);
37595 if (PyErr_Occurred()) SWIG_fail;
37596 }
37597 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37598 return resultobj;
37599 fail:
37600 return NULL;
37601 }
37602
37603
37604 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37605 PyObject *resultobj = 0;
37606 wxWindow *arg1 = (wxWindow *) 0 ;
37607 wxSize *arg2 = 0 ;
37608 wxSize result;
37609 void *argp1 = 0 ;
37610 int res1 = 0 ;
37611 wxSize temp2 ;
37612 PyObject * obj0 = 0 ;
37613 PyObject * obj1 = 0 ;
37614 char * kwnames[] = {
37615 (char *) "self",(char *) "sz", NULL
37616 };
37617
37618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37620 if (!SWIG_IsOK(res1)) {
37621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37622 }
37623 arg1 = reinterpret_cast< wxWindow * >(argp1);
37624 {
37625 arg2 = &temp2;
37626 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37627 }
37628 {
37629 PyThreadState* __tstate = wxPyBeginAllowThreads();
37630 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37631 wxPyEndAllowThreads(__tstate);
37632 if (PyErr_Occurred()) SWIG_fail;
37633 }
37634 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37635 return resultobj;
37636 fail:
37637 return NULL;
37638 }
37639
37640
37641 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37642 PyObject *resultobj = 0;
37643 wxWindow *arg1 = (wxWindow *) 0 ;
37644 wxPoint *arg2 = 0 ;
37645 wxPoint result;
37646 void *argp1 = 0 ;
37647 int res1 = 0 ;
37648 wxPoint temp2 ;
37649 PyObject * obj0 = 0 ;
37650 PyObject * obj1 = 0 ;
37651 char * kwnames[] = {
37652 (char *) "self",(char *) "pt", NULL
37653 };
37654
37655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37657 if (!SWIG_IsOK(res1)) {
37658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37659 }
37660 arg1 = reinterpret_cast< wxWindow * >(argp1);
37661 {
37662 arg2 = &temp2;
37663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37664 }
37665 {
37666 PyThreadState* __tstate = wxPyBeginAllowThreads();
37667 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37668 wxPyEndAllowThreads(__tstate);
37669 if (PyErr_Occurred()) SWIG_fail;
37670 }
37671 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj = 0;
37680 wxWindow *arg1 = (wxWindow *) 0 ;
37681 wxSize *arg2 = 0 ;
37682 wxSize result;
37683 void *argp1 = 0 ;
37684 int res1 = 0 ;
37685 wxSize temp2 ;
37686 PyObject * obj0 = 0 ;
37687 PyObject * obj1 = 0 ;
37688 char * kwnames[] = {
37689 (char *) "self",(char *) "sz", NULL
37690 };
37691
37692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37694 if (!SWIG_IsOK(res1)) {
37695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37696 }
37697 arg1 = reinterpret_cast< wxWindow * >(argp1);
37698 {
37699 arg2 = &temp2;
37700 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37701 }
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37709 return resultobj;
37710 fail:
37711 return NULL;
37712 }
37713
37714
37715 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37716 PyObject *resultobj = 0;
37717 wxWindow *arg1 = (wxWindow *) 0 ;
37718 wxPoint *arg2 = 0 ;
37719 wxPoint result;
37720 void *argp1 = 0 ;
37721 int res1 = 0 ;
37722 wxPoint temp2 ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 char * kwnames[] = {
37726 (char *) "self",(char *) "pt", NULL
37727 };
37728
37729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37731 if (!SWIG_IsOK(res1)) {
37732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37733 }
37734 arg1 = reinterpret_cast< wxWindow * >(argp1);
37735 {
37736 arg2 = &temp2;
37737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37738 }
37739 {
37740 PyThreadState* __tstate = wxPyBeginAllowThreads();
37741 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37746 return resultobj;
37747 fail:
37748 return NULL;
37749 }
37750
37751
37752 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37753 PyObject *resultobj = 0;
37754 wxWindow *arg1 = (wxWindow *) 0 ;
37755 wxSize *arg2 = 0 ;
37756 wxSize result;
37757 void *argp1 = 0 ;
37758 int res1 = 0 ;
37759 wxSize temp2 ;
37760 PyObject * obj0 = 0 ;
37761 PyObject * obj1 = 0 ;
37762 char * kwnames[] = {
37763 (char *) "self",(char *) "sz", NULL
37764 };
37765
37766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37768 if (!SWIG_IsOK(res1)) {
37769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37770 }
37771 arg1 = reinterpret_cast< wxWindow * >(argp1);
37772 {
37773 arg2 = &temp2;
37774 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37775 }
37776 {
37777 PyThreadState* __tstate = wxPyBeginAllowThreads();
37778 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37783 return resultobj;
37784 fail:
37785 return NULL;
37786 }
37787
37788
37789 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37790 PyObject *resultobj = 0;
37791 wxWindow *arg1 = (wxWindow *) 0 ;
37792 int arg2 ;
37793 int arg3 ;
37794 void *argp1 = 0 ;
37795 int res1 = 0 ;
37796 int val2 ;
37797 int ecode2 = 0 ;
37798 int val3 ;
37799 int ecode3 = 0 ;
37800 PyObject * obj0 = 0 ;
37801 PyObject * obj1 = 0 ;
37802 PyObject * obj2 = 0 ;
37803 char * kwnames[] = {
37804 (char *) "self",(char *) "x",(char *) "y", NULL
37805 };
37806
37807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37809 if (!SWIG_IsOK(res1)) {
37810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37811 }
37812 arg1 = reinterpret_cast< wxWindow * >(argp1);
37813 ecode2 = SWIG_AsVal_int(obj1, &val2);
37814 if (!SWIG_IsOK(ecode2)) {
37815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37816 }
37817 arg2 = static_cast< int >(val2);
37818 ecode3 = SWIG_AsVal_int(obj2, &val3);
37819 if (!SWIG_IsOK(ecode3)) {
37820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37821 }
37822 arg3 = static_cast< int >(val3);
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 (arg1)->WarpPointer(arg2,arg3);
37826 wxPyEndAllowThreads(__tstate);
37827 if (PyErr_Occurred()) SWIG_fail;
37828 }
37829 resultobj = SWIG_Py_Void();
37830 return resultobj;
37831 fail:
37832 return NULL;
37833 }
37834
37835
37836 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37837 PyObject *resultobj = 0;
37838 wxWindow *arg1 = (wxWindow *) 0 ;
37839 void *argp1 = 0 ;
37840 int res1 = 0 ;
37841 PyObject *swig_obj[1] ;
37842
37843 if (!args) SWIG_fail;
37844 swig_obj[0] = args;
37845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37846 if (!SWIG_IsOK(res1)) {
37847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37848 }
37849 arg1 = reinterpret_cast< wxWindow * >(argp1);
37850 {
37851 PyThreadState* __tstate = wxPyBeginAllowThreads();
37852 (arg1)->CaptureMouse();
37853 wxPyEndAllowThreads(__tstate);
37854 if (PyErr_Occurred()) SWIG_fail;
37855 }
37856 resultobj = SWIG_Py_Void();
37857 return resultobj;
37858 fail:
37859 return NULL;
37860 }
37861
37862
37863 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37864 PyObject *resultobj = 0;
37865 wxWindow *arg1 = (wxWindow *) 0 ;
37866 void *argp1 = 0 ;
37867 int res1 = 0 ;
37868 PyObject *swig_obj[1] ;
37869
37870 if (!args) SWIG_fail;
37871 swig_obj[0] = args;
37872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37873 if (!SWIG_IsOK(res1)) {
37874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37875 }
37876 arg1 = reinterpret_cast< wxWindow * >(argp1);
37877 {
37878 PyThreadState* __tstate = wxPyBeginAllowThreads();
37879 (arg1)->ReleaseMouse();
37880 wxPyEndAllowThreads(__tstate);
37881 if (PyErr_Occurred()) SWIG_fail;
37882 }
37883 resultobj = SWIG_Py_Void();
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37891 PyObject *resultobj = 0;
37892 wxWindow *result = 0 ;
37893
37894 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37895 {
37896 if (!wxPyCheckForApp()) SWIG_fail;
37897 PyThreadState* __tstate = wxPyBeginAllowThreads();
37898 result = (wxWindow *)wxWindow::GetCapture();
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 {
37903 resultobj = wxPyMake_wxObject(result, 0);
37904 }
37905 return resultobj;
37906 fail:
37907 return NULL;
37908 }
37909
37910
37911 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37912 PyObject *resultobj = 0;
37913 wxWindow *arg1 = (wxWindow *) 0 ;
37914 bool result;
37915 void *argp1 = 0 ;
37916 int res1 = 0 ;
37917 PyObject *swig_obj[1] ;
37918
37919 if (!args) SWIG_fail;
37920 swig_obj[0] = args;
37921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37922 if (!SWIG_IsOK(res1)) {
37923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37924 }
37925 arg1 = reinterpret_cast< wxWindow * >(argp1);
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (bool)((wxWindow const *)arg1)->HasCapture();
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 {
37933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37934 }
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37942 PyObject *resultobj = 0;
37943 wxWindow *arg1 = (wxWindow *) 0 ;
37944 bool arg2 = (bool) true ;
37945 wxRect *arg3 = (wxRect *) NULL ;
37946 void *argp1 = 0 ;
37947 int res1 = 0 ;
37948 bool val2 ;
37949 int ecode2 = 0 ;
37950 void *argp3 = 0 ;
37951 int res3 = 0 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 PyObject * obj2 = 0 ;
37955 char * kwnames[] = {
37956 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37957 };
37958
37959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37961 if (!SWIG_IsOK(res1)) {
37962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37963 }
37964 arg1 = reinterpret_cast< wxWindow * >(argp1);
37965 if (obj1) {
37966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37967 if (!SWIG_IsOK(ecode2)) {
37968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37969 }
37970 arg2 = static_cast< bool >(val2);
37971 }
37972 if (obj2) {
37973 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37974 if (!SWIG_IsOK(res3)) {
37975 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37976 }
37977 arg3 = reinterpret_cast< wxRect * >(argp3);
37978 }
37979 {
37980 PyThreadState* __tstate = wxPyBeginAllowThreads();
37981 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37982 wxPyEndAllowThreads(__tstate);
37983 if (PyErr_Occurred()) SWIG_fail;
37984 }
37985 resultobj = SWIG_Py_Void();
37986 return resultobj;
37987 fail:
37988 return NULL;
37989 }
37990
37991
37992 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37993 PyObject *resultobj = 0;
37994 wxWindow *arg1 = (wxWindow *) 0 ;
37995 wxRect *arg2 = 0 ;
37996 bool arg3 = (bool) true ;
37997 void *argp1 = 0 ;
37998 int res1 = 0 ;
37999 wxRect temp2 ;
38000 bool val3 ;
38001 int ecode3 = 0 ;
38002 PyObject * obj0 = 0 ;
38003 PyObject * obj1 = 0 ;
38004 PyObject * obj2 = 0 ;
38005 char * kwnames[] = {
38006 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38007 };
38008
38009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38011 if (!SWIG_IsOK(res1)) {
38012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38013 }
38014 arg1 = reinterpret_cast< wxWindow * >(argp1);
38015 {
38016 arg2 = &temp2;
38017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38018 }
38019 if (obj2) {
38020 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38021 if (!SWIG_IsOK(ecode3)) {
38022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38023 }
38024 arg3 = static_cast< bool >(val3);
38025 }
38026 {
38027 PyThreadState* __tstate = wxPyBeginAllowThreads();
38028 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38029 wxPyEndAllowThreads(__tstate);
38030 if (PyErr_Occurred()) SWIG_fail;
38031 }
38032 resultobj = SWIG_Py_Void();
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38040 PyObject *resultobj = 0;
38041 wxWindow *arg1 = (wxWindow *) 0 ;
38042 void *argp1 = 0 ;
38043 int res1 = 0 ;
38044 PyObject *swig_obj[1] ;
38045
38046 if (!args) SWIG_fail;
38047 swig_obj[0] = args;
38048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38049 if (!SWIG_IsOK(res1)) {
38050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38051 }
38052 arg1 = reinterpret_cast< wxWindow * >(argp1);
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 (arg1)->Update();
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 resultobj = SWIG_Py_Void();
38060 return resultobj;
38061 fail:
38062 return NULL;
38063 }
38064
38065
38066 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38067 PyObject *resultobj = 0;
38068 wxWindow *arg1 = (wxWindow *) 0 ;
38069 void *argp1 = 0 ;
38070 int res1 = 0 ;
38071 PyObject *swig_obj[1] ;
38072
38073 if (!args) SWIG_fail;
38074 swig_obj[0] = args;
38075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38078 }
38079 arg1 = reinterpret_cast< wxWindow * >(argp1);
38080 {
38081 PyThreadState* __tstate = wxPyBeginAllowThreads();
38082 (arg1)->ClearBackground();
38083 wxPyEndAllowThreads(__tstate);
38084 if (PyErr_Occurred()) SWIG_fail;
38085 }
38086 resultobj = SWIG_Py_Void();
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 void *argp1 = 0 ;
38097 int res1 = 0 ;
38098 PyObject *swig_obj[1] ;
38099
38100 if (!args) SWIG_fail;
38101 swig_obj[0] = args;
38102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38103 if (!SWIG_IsOK(res1)) {
38104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38105 }
38106 arg1 = reinterpret_cast< wxWindow * >(argp1);
38107 {
38108 PyThreadState* __tstate = wxPyBeginAllowThreads();
38109 (arg1)->Freeze();
38110 wxPyEndAllowThreads(__tstate);
38111 if (PyErr_Occurred()) SWIG_fail;
38112 }
38113 resultobj = SWIG_Py_Void();
38114 return resultobj;
38115 fail:
38116 return NULL;
38117 }
38118
38119
38120 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38121 PyObject *resultobj = 0;
38122 wxWindow *arg1 = (wxWindow *) 0 ;
38123 bool result;
38124 void *argp1 = 0 ;
38125 int res1 = 0 ;
38126 PyObject *swig_obj[1] ;
38127
38128 if (!args) SWIG_fail;
38129 swig_obj[0] = args;
38130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38131 if (!SWIG_IsOK(res1)) {
38132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38133 }
38134 arg1 = reinterpret_cast< wxWindow * >(argp1);
38135 {
38136 PyThreadState* __tstate = wxPyBeginAllowThreads();
38137 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38138 wxPyEndAllowThreads(__tstate);
38139 if (PyErr_Occurred()) SWIG_fail;
38140 }
38141 {
38142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38143 }
38144 return resultobj;
38145 fail:
38146 return NULL;
38147 }
38148
38149
38150 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38151 PyObject *resultobj = 0;
38152 wxWindow *arg1 = (wxWindow *) 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 PyObject *swig_obj[1] ;
38156
38157 if (!args) SWIG_fail;
38158 swig_obj[0] = args;
38159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38162 }
38163 arg1 = reinterpret_cast< wxWindow * >(argp1);
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 (arg1)->Thaw();
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 resultobj = SWIG_Py_Void();
38171 return resultobj;
38172 fail:
38173 return NULL;
38174 }
38175
38176
38177 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38178 PyObject *resultobj = 0;
38179 wxWindow *arg1 = (wxWindow *) 0 ;
38180 wxDC *arg2 = 0 ;
38181 void *argp1 = 0 ;
38182 int res1 = 0 ;
38183 void *argp2 = 0 ;
38184 int res2 = 0 ;
38185 PyObject * obj0 = 0 ;
38186 PyObject * obj1 = 0 ;
38187 char * kwnames[] = {
38188 (char *) "self",(char *) "dc", NULL
38189 };
38190
38191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38193 if (!SWIG_IsOK(res1)) {
38194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38195 }
38196 arg1 = reinterpret_cast< wxWindow * >(argp1);
38197 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38198 if (!SWIG_IsOK(res2)) {
38199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38200 }
38201 if (!argp2) {
38202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38203 }
38204 arg2 = reinterpret_cast< wxDC * >(argp2);
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 (arg1)->PrepareDC(*arg2);
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 resultobj = SWIG_Py_Void();
38212 return resultobj;
38213 fail:
38214 return NULL;
38215 }
38216
38217
38218 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38219 PyObject *resultobj = 0;
38220 wxWindow *arg1 = (wxWindow *) 0 ;
38221 bool result;
38222 void *argp1 = 0 ;
38223 int res1 = 0 ;
38224 PyObject *swig_obj[1] ;
38225
38226 if (!args) SWIG_fail;
38227 swig_obj[0] = args;
38228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38229 if (!SWIG_IsOK(res1)) {
38230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38231 }
38232 arg1 = reinterpret_cast< wxWindow * >(argp1);
38233 {
38234 PyThreadState* __tstate = wxPyBeginAllowThreads();
38235 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38236 wxPyEndAllowThreads(__tstate);
38237 if (PyErr_Occurred()) SWIG_fail;
38238 }
38239 {
38240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38241 }
38242 return resultobj;
38243 fail:
38244 return NULL;
38245 }
38246
38247
38248 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38249 PyObject *resultobj = 0;
38250 wxWindow *arg1 = (wxWindow *) 0 ;
38251 wxRegion *result = 0 ;
38252 void *argp1 = 0 ;
38253 int res1 = 0 ;
38254 PyObject *swig_obj[1] ;
38255
38256 if (!args) SWIG_fail;
38257 swig_obj[0] = args;
38258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38259 if (!SWIG_IsOK(res1)) {
38260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38261 }
38262 arg1 = reinterpret_cast< wxWindow * >(argp1);
38263 {
38264 PyThreadState* __tstate = wxPyBeginAllowThreads();
38265 {
38266 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38267 result = (wxRegion *) &_result_ref;
38268 }
38269 wxPyEndAllowThreads(__tstate);
38270 if (PyErr_Occurred()) SWIG_fail;
38271 }
38272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38273 return resultobj;
38274 fail:
38275 return NULL;
38276 }
38277
38278
38279 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38280 PyObject *resultobj = 0;
38281 wxWindow *arg1 = (wxWindow *) 0 ;
38282 wxRect result;
38283 void *argp1 = 0 ;
38284 int res1 = 0 ;
38285 PyObject *swig_obj[1] ;
38286
38287 if (!args) SWIG_fail;
38288 swig_obj[0] = args;
38289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38290 if (!SWIG_IsOK(res1)) {
38291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38292 }
38293 arg1 = reinterpret_cast< wxWindow * >(argp1);
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38297 wxPyEndAllowThreads(__tstate);
38298 if (PyErr_Occurred()) SWIG_fail;
38299 }
38300 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38301 return resultobj;
38302 fail:
38303 return NULL;
38304 }
38305
38306
38307 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38308 PyObject *resultobj = 0;
38309 wxWindow *arg1 = (wxWindow *) 0 ;
38310 int arg2 ;
38311 int arg3 ;
38312 int arg4 = (int) 1 ;
38313 int arg5 = (int) 1 ;
38314 bool result;
38315 void *argp1 = 0 ;
38316 int res1 = 0 ;
38317 int val2 ;
38318 int ecode2 = 0 ;
38319 int val3 ;
38320 int ecode3 = 0 ;
38321 int val4 ;
38322 int ecode4 = 0 ;
38323 int val5 ;
38324 int ecode5 = 0 ;
38325 PyObject * obj0 = 0 ;
38326 PyObject * obj1 = 0 ;
38327 PyObject * obj2 = 0 ;
38328 PyObject * obj3 = 0 ;
38329 PyObject * obj4 = 0 ;
38330 char * kwnames[] = {
38331 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38332 };
38333
38334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38336 if (!SWIG_IsOK(res1)) {
38337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38338 }
38339 arg1 = reinterpret_cast< wxWindow * >(argp1);
38340 ecode2 = SWIG_AsVal_int(obj1, &val2);
38341 if (!SWIG_IsOK(ecode2)) {
38342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38343 }
38344 arg2 = static_cast< int >(val2);
38345 ecode3 = SWIG_AsVal_int(obj2, &val3);
38346 if (!SWIG_IsOK(ecode3)) {
38347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38348 }
38349 arg3 = static_cast< int >(val3);
38350 if (obj3) {
38351 ecode4 = SWIG_AsVal_int(obj3, &val4);
38352 if (!SWIG_IsOK(ecode4)) {
38353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38354 }
38355 arg4 = static_cast< int >(val4);
38356 }
38357 if (obj4) {
38358 ecode5 = SWIG_AsVal_int(obj4, &val5);
38359 if (!SWIG_IsOK(ecode5)) {
38360 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38361 }
38362 arg5 = static_cast< int >(val5);
38363 }
38364 {
38365 PyThreadState* __tstate = wxPyBeginAllowThreads();
38366 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38367 wxPyEndAllowThreads(__tstate);
38368 if (PyErr_Occurred()) SWIG_fail;
38369 }
38370 {
38371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38372 }
38373 return resultobj;
38374 fail:
38375 return NULL;
38376 }
38377
38378
38379 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38380 PyObject *resultobj = 0;
38381 wxWindow *arg1 = (wxWindow *) 0 ;
38382 wxPoint *arg2 = 0 ;
38383 bool result;
38384 void *argp1 = 0 ;
38385 int res1 = 0 ;
38386 wxPoint temp2 ;
38387 PyObject * obj0 = 0 ;
38388 PyObject * obj1 = 0 ;
38389 char * kwnames[] = {
38390 (char *) "self",(char *) "pt", NULL
38391 };
38392
38393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38395 if (!SWIG_IsOK(res1)) {
38396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38397 }
38398 arg1 = reinterpret_cast< wxWindow * >(argp1);
38399 {
38400 arg2 = &temp2;
38401 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38402 }
38403 {
38404 PyThreadState* __tstate = wxPyBeginAllowThreads();
38405 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38406 wxPyEndAllowThreads(__tstate);
38407 if (PyErr_Occurred()) SWIG_fail;
38408 }
38409 {
38410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38411 }
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38419 PyObject *resultobj = 0;
38420 wxWindow *arg1 = (wxWindow *) 0 ;
38421 wxRect *arg2 = 0 ;
38422 bool result;
38423 void *argp1 = 0 ;
38424 int res1 = 0 ;
38425 wxRect temp2 ;
38426 PyObject * obj0 = 0 ;
38427 PyObject * obj1 = 0 ;
38428 char * kwnames[] = {
38429 (char *) "self",(char *) "rect", NULL
38430 };
38431
38432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38434 if (!SWIG_IsOK(res1)) {
38435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38436 }
38437 arg1 = reinterpret_cast< wxWindow * >(argp1);
38438 {
38439 arg2 = &temp2;
38440 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38441 }
38442 {
38443 PyThreadState* __tstate = wxPyBeginAllowThreads();
38444 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38445 wxPyEndAllowThreads(__tstate);
38446 if (PyErr_Occurred()) SWIG_fail;
38447 }
38448 {
38449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38450 }
38451 return resultobj;
38452 fail:
38453 return NULL;
38454 }
38455
38456
38457 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38458 PyObject *resultobj = 0;
38459 wxWindow *arg1 = (wxWindow *) 0 ;
38460 SwigValueWrapper<wxVisualAttributes > result;
38461 void *argp1 = 0 ;
38462 int res1 = 0 ;
38463 PyObject *swig_obj[1] ;
38464
38465 if (!args) SWIG_fail;
38466 swig_obj[0] = args;
38467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38468 if (!SWIG_IsOK(res1)) {
38469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38470 }
38471 arg1 = reinterpret_cast< wxWindow * >(argp1);
38472 {
38473 PyThreadState* __tstate = wxPyBeginAllowThreads();
38474 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38479 return resultobj;
38480 fail:
38481 return NULL;
38482 }
38483
38484
38485 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38486 PyObject *resultobj = 0;
38487 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38488 SwigValueWrapper<wxVisualAttributes > result;
38489 int val1 ;
38490 int ecode1 = 0 ;
38491 PyObject * obj0 = 0 ;
38492 char * kwnames[] = {
38493 (char *) "variant", NULL
38494 };
38495
38496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38497 if (obj0) {
38498 ecode1 = SWIG_AsVal_int(obj0, &val1);
38499 if (!SWIG_IsOK(ecode1)) {
38500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38501 }
38502 arg1 = static_cast< wxWindowVariant >(val1);
38503 }
38504 {
38505 if (!wxPyCheckForApp()) SWIG_fail;
38506 PyThreadState* __tstate = wxPyBeginAllowThreads();
38507 result = wxWindow::GetClassDefaultAttributes(arg1);
38508 wxPyEndAllowThreads(__tstate);
38509 if (PyErr_Occurred()) SWIG_fail;
38510 }
38511 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38512 return resultobj;
38513 fail:
38514 return NULL;
38515 }
38516
38517
38518 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38519 PyObject *resultobj = 0;
38520 wxWindow *arg1 = (wxWindow *) 0 ;
38521 wxColour *arg2 = 0 ;
38522 bool result;
38523 void *argp1 = 0 ;
38524 int res1 = 0 ;
38525 wxColour temp2 ;
38526 PyObject * obj0 = 0 ;
38527 PyObject * obj1 = 0 ;
38528 char * kwnames[] = {
38529 (char *) "self",(char *) "colour", NULL
38530 };
38531
38532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38536 }
38537 arg1 = reinterpret_cast< wxWindow * >(argp1);
38538 {
38539 arg2 = &temp2;
38540 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38541 }
38542 {
38543 PyThreadState* __tstate = wxPyBeginAllowThreads();
38544 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38545 wxPyEndAllowThreads(__tstate);
38546 if (PyErr_Occurred()) SWIG_fail;
38547 }
38548 {
38549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38550 }
38551 return resultobj;
38552 fail:
38553 return NULL;
38554 }
38555
38556
38557 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38558 PyObject *resultobj = 0;
38559 wxWindow *arg1 = (wxWindow *) 0 ;
38560 wxColour *arg2 = 0 ;
38561 void *argp1 = 0 ;
38562 int res1 = 0 ;
38563 wxColour temp2 ;
38564 PyObject * obj0 = 0 ;
38565 PyObject * obj1 = 0 ;
38566 char * kwnames[] = {
38567 (char *) "self",(char *) "colour", NULL
38568 };
38569
38570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38572 if (!SWIG_IsOK(res1)) {
38573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38574 }
38575 arg1 = reinterpret_cast< wxWindow * >(argp1);
38576 {
38577 arg2 = &temp2;
38578 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38579 }
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 resultobj = SWIG_Py_Void();
38587 return resultobj;
38588 fail:
38589 return NULL;
38590 }
38591
38592
38593 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38594 PyObject *resultobj = 0;
38595 wxWindow *arg1 = (wxWindow *) 0 ;
38596 wxColour *arg2 = 0 ;
38597 bool result;
38598 void *argp1 = 0 ;
38599 int res1 = 0 ;
38600 wxColour temp2 ;
38601 PyObject * obj0 = 0 ;
38602 PyObject * obj1 = 0 ;
38603 char * kwnames[] = {
38604 (char *) "self",(char *) "colour", NULL
38605 };
38606
38607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38609 if (!SWIG_IsOK(res1)) {
38610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38611 }
38612 arg1 = reinterpret_cast< wxWindow * >(argp1);
38613 {
38614 arg2 = &temp2;
38615 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38616 }
38617 {
38618 PyThreadState* __tstate = wxPyBeginAllowThreads();
38619 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38620 wxPyEndAllowThreads(__tstate);
38621 if (PyErr_Occurred()) SWIG_fail;
38622 }
38623 {
38624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38625 }
38626 return resultobj;
38627 fail:
38628 return NULL;
38629 }
38630
38631
38632 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38633 PyObject *resultobj = 0;
38634 wxWindow *arg1 = (wxWindow *) 0 ;
38635 wxColour *arg2 = 0 ;
38636 void *argp1 = 0 ;
38637 int res1 = 0 ;
38638 wxColour temp2 ;
38639 PyObject * obj0 = 0 ;
38640 PyObject * obj1 = 0 ;
38641 char * kwnames[] = {
38642 (char *) "self",(char *) "colour", NULL
38643 };
38644
38645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38647 if (!SWIG_IsOK(res1)) {
38648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38649 }
38650 arg1 = reinterpret_cast< wxWindow * >(argp1);
38651 {
38652 arg2 = &temp2;
38653 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38654 }
38655 {
38656 PyThreadState* __tstate = wxPyBeginAllowThreads();
38657 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38658 wxPyEndAllowThreads(__tstate);
38659 if (PyErr_Occurred()) SWIG_fail;
38660 }
38661 resultobj = SWIG_Py_Void();
38662 return resultobj;
38663 fail:
38664 return NULL;
38665 }
38666
38667
38668 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38669 PyObject *resultobj = 0;
38670 wxWindow *arg1 = (wxWindow *) 0 ;
38671 wxColour result;
38672 void *argp1 = 0 ;
38673 int res1 = 0 ;
38674 PyObject *swig_obj[1] ;
38675
38676 if (!args) SWIG_fail;
38677 swig_obj[0] = args;
38678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38679 if (!SWIG_IsOK(res1)) {
38680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38681 }
38682 arg1 = reinterpret_cast< wxWindow * >(argp1);
38683 {
38684 PyThreadState* __tstate = wxPyBeginAllowThreads();
38685 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38686 wxPyEndAllowThreads(__tstate);
38687 if (PyErr_Occurred()) SWIG_fail;
38688 }
38689 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38690 return resultobj;
38691 fail:
38692 return NULL;
38693 }
38694
38695
38696 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38697 PyObject *resultobj = 0;
38698 wxWindow *arg1 = (wxWindow *) 0 ;
38699 wxColour result;
38700 void *argp1 = 0 ;
38701 int res1 = 0 ;
38702 PyObject *swig_obj[1] ;
38703
38704 if (!args) SWIG_fail;
38705 swig_obj[0] = args;
38706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38707 if (!SWIG_IsOK(res1)) {
38708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38709 }
38710 arg1 = reinterpret_cast< wxWindow * >(argp1);
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 result = ((wxWindow const *)arg1)->GetForegroundColour();
38714 wxPyEndAllowThreads(__tstate);
38715 if (PyErr_Occurred()) SWIG_fail;
38716 }
38717 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38718 return resultobj;
38719 fail:
38720 return NULL;
38721 }
38722
38723
38724 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38725 PyObject *resultobj = 0;
38726 wxWindow *arg1 = (wxWindow *) 0 ;
38727 bool result;
38728 void *argp1 = 0 ;
38729 int res1 = 0 ;
38730 PyObject *swig_obj[1] ;
38731
38732 if (!args) SWIG_fail;
38733 swig_obj[0] = args;
38734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38735 if (!SWIG_IsOK(res1)) {
38736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38737 }
38738 arg1 = reinterpret_cast< wxWindow * >(argp1);
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 {
38746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38747 }
38748 return resultobj;
38749 fail:
38750 return NULL;
38751 }
38752
38753
38754 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38755 PyObject *resultobj = 0;
38756 wxWindow *arg1 = (wxWindow *) 0 ;
38757 bool result;
38758 void *argp1 = 0 ;
38759 int res1 = 0 ;
38760 PyObject *swig_obj[1] ;
38761
38762 if (!args) SWIG_fail;
38763 swig_obj[0] = args;
38764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38765 if (!SWIG_IsOK(res1)) {
38766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38767 }
38768 arg1 = reinterpret_cast< wxWindow * >(argp1);
38769 {
38770 PyThreadState* __tstate = wxPyBeginAllowThreads();
38771 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38772 wxPyEndAllowThreads(__tstate);
38773 if (PyErr_Occurred()) SWIG_fail;
38774 }
38775 {
38776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38777 }
38778 return resultobj;
38779 fail:
38780 return NULL;
38781 }
38782
38783
38784 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38785 PyObject *resultobj = 0;
38786 wxWindow *arg1 = (wxWindow *) 0 ;
38787 wxBackgroundStyle arg2 ;
38788 bool result;
38789 void *argp1 = 0 ;
38790 int res1 = 0 ;
38791 int val2 ;
38792 int ecode2 = 0 ;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 char * kwnames[] = {
38796 (char *) "self",(char *) "style", NULL
38797 };
38798
38799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38803 }
38804 arg1 = reinterpret_cast< wxWindow * >(argp1);
38805 ecode2 = SWIG_AsVal_int(obj1, &val2);
38806 if (!SWIG_IsOK(ecode2)) {
38807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38808 }
38809 arg2 = static_cast< wxBackgroundStyle >(val2);
38810 {
38811 PyThreadState* __tstate = wxPyBeginAllowThreads();
38812 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38813 wxPyEndAllowThreads(__tstate);
38814 if (PyErr_Occurred()) SWIG_fail;
38815 }
38816 {
38817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38818 }
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38826 PyObject *resultobj = 0;
38827 wxWindow *arg1 = (wxWindow *) 0 ;
38828 wxBackgroundStyle result;
38829 void *argp1 = 0 ;
38830 int res1 = 0 ;
38831 PyObject *swig_obj[1] ;
38832
38833 if (!args) SWIG_fail;
38834 swig_obj[0] = args;
38835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38838 }
38839 arg1 = reinterpret_cast< wxWindow * >(argp1);
38840 {
38841 PyThreadState* __tstate = wxPyBeginAllowThreads();
38842 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 resultobj = SWIG_From_int(static_cast< int >(result));
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38854 PyObject *resultobj = 0;
38855 wxWindow *arg1 = (wxWindow *) 0 ;
38856 bool result;
38857 void *argp1 = 0 ;
38858 int res1 = 0 ;
38859 PyObject *swig_obj[1] ;
38860
38861 if (!args) SWIG_fail;
38862 swig_obj[0] = args;
38863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38864 if (!SWIG_IsOK(res1)) {
38865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38866 }
38867 arg1 = reinterpret_cast< wxWindow * >(argp1);
38868 {
38869 PyThreadState* __tstate = wxPyBeginAllowThreads();
38870 result = (bool)(arg1)->HasTransparentBackground();
38871 wxPyEndAllowThreads(__tstate);
38872 if (PyErr_Occurred()) SWIG_fail;
38873 }
38874 {
38875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38876 }
38877 return resultobj;
38878 fail:
38879 return NULL;
38880 }
38881
38882
38883 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38884 PyObject *resultobj = 0;
38885 wxWindow *arg1 = (wxWindow *) 0 ;
38886 wxCursor *arg2 = 0 ;
38887 bool result;
38888 void *argp1 = 0 ;
38889 int res1 = 0 ;
38890 void *argp2 = 0 ;
38891 int res2 = 0 ;
38892 PyObject * obj0 = 0 ;
38893 PyObject * obj1 = 0 ;
38894 char * kwnames[] = {
38895 (char *) "self",(char *) "cursor", NULL
38896 };
38897
38898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38900 if (!SWIG_IsOK(res1)) {
38901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38902 }
38903 arg1 = reinterpret_cast< wxWindow * >(argp1);
38904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38905 if (!SWIG_IsOK(res2)) {
38906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38907 }
38908 if (!argp2) {
38909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38910 }
38911 arg2 = reinterpret_cast< wxCursor * >(argp2);
38912 {
38913 PyThreadState* __tstate = wxPyBeginAllowThreads();
38914 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38915 wxPyEndAllowThreads(__tstate);
38916 if (PyErr_Occurred()) SWIG_fail;
38917 }
38918 {
38919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38920 }
38921 return resultobj;
38922 fail:
38923 return NULL;
38924 }
38925
38926
38927 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38928 PyObject *resultobj = 0;
38929 wxWindow *arg1 = (wxWindow *) 0 ;
38930 wxCursor result;
38931 void *argp1 = 0 ;
38932 int res1 = 0 ;
38933 PyObject *swig_obj[1] ;
38934
38935 if (!args) SWIG_fail;
38936 swig_obj[0] = args;
38937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38938 if (!SWIG_IsOK(res1)) {
38939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38940 }
38941 arg1 = reinterpret_cast< wxWindow * >(argp1);
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 result = (arg1)->GetCursor();
38945 wxPyEndAllowThreads(__tstate);
38946 if (PyErr_Occurred()) SWIG_fail;
38947 }
38948 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38949 return resultobj;
38950 fail:
38951 return NULL;
38952 }
38953
38954
38955 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38956 PyObject *resultobj = 0;
38957 wxWindow *arg1 = (wxWindow *) 0 ;
38958 wxFont *arg2 = 0 ;
38959 bool result;
38960 void *argp1 = 0 ;
38961 int res1 = 0 ;
38962 void *argp2 = 0 ;
38963 int res2 = 0 ;
38964 PyObject * obj0 = 0 ;
38965 PyObject * obj1 = 0 ;
38966 char * kwnames[] = {
38967 (char *) "self",(char *) "font", NULL
38968 };
38969
38970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38972 if (!SWIG_IsOK(res1)) {
38973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38974 }
38975 arg1 = reinterpret_cast< wxWindow * >(argp1);
38976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38977 if (!SWIG_IsOK(res2)) {
38978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38979 }
38980 if (!argp2) {
38981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38982 }
38983 arg2 = reinterpret_cast< wxFont * >(argp2);
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38992 }
38993 return resultobj;
38994 fail:
38995 return NULL;
38996 }
38997
38998
38999 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39000 PyObject *resultobj = 0;
39001 wxWindow *arg1 = (wxWindow *) 0 ;
39002 wxFont *arg2 = 0 ;
39003 void *argp1 = 0 ;
39004 int res1 = 0 ;
39005 void *argp2 = 0 ;
39006 int res2 = 0 ;
39007 PyObject * obj0 = 0 ;
39008 PyObject * obj1 = 0 ;
39009 char * kwnames[] = {
39010 (char *) "self",(char *) "font", NULL
39011 };
39012
39013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39015 if (!SWIG_IsOK(res1)) {
39016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39017 }
39018 arg1 = reinterpret_cast< wxWindow * >(argp1);
39019 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39020 if (!SWIG_IsOK(res2)) {
39021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39022 }
39023 if (!argp2) {
39024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39025 }
39026 arg2 = reinterpret_cast< wxFont * >(argp2);
39027 {
39028 PyThreadState* __tstate = wxPyBeginAllowThreads();
39029 (arg1)->SetOwnFont((wxFont const &)*arg2);
39030 wxPyEndAllowThreads(__tstate);
39031 if (PyErr_Occurred()) SWIG_fail;
39032 }
39033 resultobj = SWIG_Py_Void();
39034 return resultobj;
39035 fail:
39036 return NULL;
39037 }
39038
39039
39040 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39041 PyObject *resultobj = 0;
39042 wxWindow *arg1 = (wxWindow *) 0 ;
39043 wxFont result;
39044 void *argp1 = 0 ;
39045 int res1 = 0 ;
39046 PyObject *swig_obj[1] ;
39047
39048 if (!args) SWIG_fail;
39049 swig_obj[0] = args;
39050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39051 if (!SWIG_IsOK(res1)) {
39052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39053 }
39054 arg1 = reinterpret_cast< wxWindow * >(argp1);
39055 {
39056 PyThreadState* __tstate = wxPyBeginAllowThreads();
39057 result = (arg1)->GetFont();
39058 wxPyEndAllowThreads(__tstate);
39059 if (PyErr_Occurred()) SWIG_fail;
39060 }
39061 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39062 return resultobj;
39063 fail:
39064 return NULL;
39065 }
39066
39067
39068 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39069 PyObject *resultobj = 0;
39070 wxWindow *arg1 = (wxWindow *) 0 ;
39071 wxCaret *arg2 = (wxCaret *) 0 ;
39072 void *argp1 = 0 ;
39073 int res1 = 0 ;
39074 int res2 = 0 ;
39075 PyObject * obj0 = 0 ;
39076 PyObject * obj1 = 0 ;
39077 char * kwnames[] = {
39078 (char *) "self",(char *) "caret", NULL
39079 };
39080
39081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39083 if (!SWIG_IsOK(res1)) {
39084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39085 }
39086 arg1 = reinterpret_cast< wxWindow * >(argp1);
39087 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39088 if (!SWIG_IsOK(res2)) {
39089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39090 }
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 (arg1)->SetCaret(arg2);
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 resultobj = SWIG_Py_Void();
39098 return resultobj;
39099 fail:
39100 return NULL;
39101 }
39102
39103
39104 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39105 PyObject *resultobj = 0;
39106 wxWindow *arg1 = (wxWindow *) 0 ;
39107 wxCaret *result = 0 ;
39108 void *argp1 = 0 ;
39109 int res1 = 0 ;
39110 PyObject *swig_obj[1] ;
39111
39112 if (!args) SWIG_fail;
39113 swig_obj[0] = args;
39114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39115 if (!SWIG_IsOK(res1)) {
39116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39117 }
39118 arg1 = reinterpret_cast< wxWindow * >(argp1);
39119 {
39120 PyThreadState* __tstate = wxPyBeginAllowThreads();
39121 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39122 wxPyEndAllowThreads(__tstate);
39123 if (PyErr_Occurred()) SWIG_fail;
39124 }
39125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39126 return resultobj;
39127 fail:
39128 return NULL;
39129 }
39130
39131
39132 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39133 PyObject *resultobj = 0;
39134 wxWindow *arg1 = (wxWindow *) 0 ;
39135 int result;
39136 void *argp1 = 0 ;
39137 int res1 = 0 ;
39138 PyObject *swig_obj[1] ;
39139
39140 if (!args) SWIG_fail;
39141 swig_obj[0] = args;
39142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39143 if (!SWIG_IsOK(res1)) {
39144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39145 }
39146 arg1 = reinterpret_cast< wxWindow * >(argp1);
39147 {
39148 PyThreadState* __tstate = wxPyBeginAllowThreads();
39149 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39150 wxPyEndAllowThreads(__tstate);
39151 if (PyErr_Occurred()) SWIG_fail;
39152 }
39153 resultobj = SWIG_From_int(static_cast< int >(result));
39154 return resultobj;
39155 fail:
39156 return NULL;
39157 }
39158
39159
39160 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39161 PyObject *resultobj = 0;
39162 wxWindow *arg1 = (wxWindow *) 0 ;
39163 int result;
39164 void *argp1 = 0 ;
39165 int res1 = 0 ;
39166 PyObject *swig_obj[1] ;
39167
39168 if (!args) SWIG_fail;
39169 swig_obj[0] = args;
39170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39171 if (!SWIG_IsOK(res1)) {
39172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39173 }
39174 arg1 = reinterpret_cast< wxWindow * >(argp1);
39175 {
39176 PyThreadState* __tstate = wxPyBeginAllowThreads();
39177 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39178 wxPyEndAllowThreads(__tstate);
39179 if (PyErr_Occurred()) SWIG_fail;
39180 }
39181 resultobj = SWIG_From_int(static_cast< int >(result));
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39189 PyObject *resultobj = 0;
39190 wxWindow *arg1 = (wxWindow *) 0 ;
39191 wxString *arg2 = 0 ;
39192 int *arg3 = (int *) 0 ;
39193 int *arg4 = (int *) 0 ;
39194 void *argp1 = 0 ;
39195 int res1 = 0 ;
39196 bool temp2 = false ;
39197 int temp3 ;
39198 int res3 = SWIG_TMPOBJ ;
39199 int temp4 ;
39200 int res4 = SWIG_TMPOBJ ;
39201 PyObject * obj0 = 0 ;
39202 PyObject * obj1 = 0 ;
39203 char * kwnames[] = {
39204 (char *) "self",(char *) "string", NULL
39205 };
39206
39207 arg3 = &temp3;
39208 arg4 = &temp4;
39209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39211 if (!SWIG_IsOK(res1)) {
39212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39213 }
39214 arg1 = reinterpret_cast< wxWindow * >(argp1);
39215 {
39216 arg2 = wxString_in_helper(obj1);
39217 if (arg2 == NULL) SWIG_fail;
39218 temp2 = true;
39219 }
39220 {
39221 PyThreadState* __tstate = wxPyBeginAllowThreads();
39222 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39223 wxPyEndAllowThreads(__tstate);
39224 if (PyErr_Occurred()) SWIG_fail;
39225 }
39226 resultobj = SWIG_Py_Void();
39227 if (SWIG_IsTmpObj(res3)) {
39228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39229 } else {
39230 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39232 }
39233 if (SWIG_IsTmpObj(res4)) {
39234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39235 } else {
39236 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39238 }
39239 {
39240 if (temp2)
39241 delete arg2;
39242 }
39243 return resultobj;
39244 fail:
39245 {
39246 if (temp2)
39247 delete arg2;
39248 }
39249 return NULL;
39250 }
39251
39252
39253 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39254 PyObject *resultobj = 0;
39255 wxWindow *arg1 = (wxWindow *) 0 ;
39256 wxString *arg2 = 0 ;
39257 int *arg3 = (int *) 0 ;
39258 int *arg4 = (int *) 0 ;
39259 int *arg5 = (int *) 0 ;
39260 int *arg6 = (int *) 0 ;
39261 wxFont *arg7 = (wxFont *) NULL ;
39262 void *argp1 = 0 ;
39263 int res1 = 0 ;
39264 bool temp2 = false ;
39265 int temp3 ;
39266 int res3 = SWIG_TMPOBJ ;
39267 int temp4 ;
39268 int res4 = SWIG_TMPOBJ ;
39269 int temp5 ;
39270 int res5 = SWIG_TMPOBJ ;
39271 int temp6 ;
39272 int res6 = SWIG_TMPOBJ ;
39273 void *argp7 = 0 ;
39274 int res7 = 0 ;
39275 PyObject * obj0 = 0 ;
39276 PyObject * obj1 = 0 ;
39277 PyObject * obj2 = 0 ;
39278 char * kwnames[] = {
39279 (char *) "self",(char *) "string",(char *) "font", NULL
39280 };
39281
39282 arg3 = &temp3;
39283 arg4 = &temp4;
39284 arg5 = &temp5;
39285 arg6 = &temp6;
39286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39288 if (!SWIG_IsOK(res1)) {
39289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39290 }
39291 arg1 = reinterpret_cast< wxWindow * >(argp1);
39292 {
39293 arg2 = wxString_in_helper(obj1);
39294 if (arg2 == NULL) SWIG_fail;
39295 temp2 = true;
39296 }
39297 if (obj2) {
39298 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39299 if (!SWIG_IsOK(res7)) {
39300 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39301 }
39302 arg7 = reinterpret_cast< wxFont * >(argp7);
39303 }
39304 {
39305 PyThreadState* __tstate = wxPyBeginAllowThreads();
39306 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39307 wxPyEndAllowThreads(__tstate);
39308 if (PyErr_Occurred()) SWIG_fail;
39309 }
39310 resultobj = SWIG_Py_Void();
39311 if (SWIG_IsTmpObj(res3)) {
39312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39313 } else {
39314 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39316 }
39317 if (SWIG_IsTmpObj(res4)) {
39318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39319 } else {
39320 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39322 }
39323 if (SWIG_IsTmpObj(res5)) {
39324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39325 } else {
39326 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39328 }
39329 if (SWIG_IsTmpObj(res6)) {
39330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39331 } else {
39332 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39334 }
39335 {
39336 if (temp2)
39337 delete arg2;
39338 }
39339 return resultobj;
39340 fail:
39341 {
39342 if (temp2)
39343 delete arg2;
39344 }
39345 return NULL;
39346 }
39347
39348
39349 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39350 PyObject *resultobj = 0;
39351 wxWindow *arg1 = (wxWindow *) 0 ;
39352 int *arg2 = (int *) 0 ;
39353 int *arg3 = (int *) 0 ;
39354 void *argp1 = 0 ;
39355 int res1 = 0 ;
39356 int temp2 ;
39357 int res2 = 0 ;
39358 int temp3 ;
39359 int res3 = 0 ;
39360 PyObject * obj0 = 0 ;
39361 PyObject * obj1 = 0 ;
39362 PyObject * obj2 = 0 ;
39363 char * kwnames[] = {
39364 (char *) "self",(char *) "x",(char *) "y", NULL
39365 };
39366
39367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39369 if (!SWIG_IsOK(res1)) {
39370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39371 }
39372 arg1 = reinterpret_cast< wxWindow * >(argp1);
39373 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39374 int val;
39375 int ecode = SWIG_AsVal_int(obj1, &val);
39376 if (!SWIG_IsOK(ecode)) {
39377 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39378 }
39379 temp2 = static_cast< int >(val);
39380 arg2 = &temp2;
39381 res2 = SWIG_AddTmpMask(ecode);
39382 }
39383 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39384 int val;
39385 int ecode = SWIG_AsVal_int(obj2, &val);
39386 if (!SWIG_IsOK(ecode)) {
39387 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39388 }
39389 temp3 = static_cast< int >(val);
39390 arg3 = &temp3;
39391 res3 = SWIG_AddTmpMask(ecode);
39392 }
39393 {
39394 PyThreadState* __tstate = wxPyBeginAllowThreads();
39395 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39396 wxPyEndAllowThreads(__tstate);
39397 if (PyErr_Occurred()) SWIG_fail;
39398 }
39399 resultobj = SWIG_Py_Void();
39400 if (SWIG_IsTmpObj(res2)) {
39401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39402 } else {
39403 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39405 }
39406 if (SWIG_IsTmpObj(res3)) {
39407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39408 } else {
39409 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39411 }
39412 return resultobj;
39413 fail:
39414 return NULL;
39415 }
39416
39417
39418 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39419 PyObject *resultobj = 0;
39420 wxWindow *arg1 = (wxWindow *) 0 ;
39421 int *arg2 = (int *) 0 ;
39422 int *arg3 = (int *) 0 ;
39423 void *argp1 = 0 ;
39424 int res1 = 0 ;
39425 int temp2 ;
39426 int res2 = 0 ;
39427 int temp3 ;
39428 int res3 = 0 ;
39429 PyObject * obj0 = 0 ;
39430 PyObject * obj1 = 0 ;
39431 PyObject * obj2 = 0 ;
39432 char * kwnames[] = {
39433 (char *) "self",(char *) "x",(char *) "y", NULL
39434 };
39435
39436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39438 if (!SWIG_IsOK(res1)) {
39439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39440 }
39441 arg1 = reinterpret_cast< wxWindow * >(argp1);
39442 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39443 int val;
39444 int ecode = SWIG_AsVal_int(obj1, &val);
39445 if (!SWIG_IsOK(ecode)) {
39446 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39447 }
39448 temp2 = static_cast< int >(val);
39449 arg2 = &temp2;
39450 res2 = SWIG_AddTmpMask(ecode);
39451 }
39452 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39453 int val;
39454 int ecode = SWIG_AsVal_int(obj2, &val);
39455 if (!SWIG_IsOK(ecode)) {
39456 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39457 }
39458 temp3 = static_cast< int >(val);
39459 arg3 = &temp3;
39460 res3 = SWIG_AddTmpMask(ecode);
39461 }
39462 {
39463 PyThreadState* __tstate = wxPyBeginAllowThreads();
39464 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39465 wxPyEndAllowThreads(__tstate);
39466 if (PyErr_Occurred()) SWIG_fail;
39467 }
39468 resultobj = SWIG_Py_Void();
39469 if (SWIG_IsTmpObj(res2)) {
39470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39471 } else {
39472 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39474 }
39475 if (SWIG_IsTmpObj(res3)) {
39476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39477 } else {
39478 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39480 }
39481 return resultobj;
39482 fail:
39483 return NULL;
39484 }
39485
39486
39487 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39488 PyObject *resultobj = 0;
39489 wxWindow *arg1 = (wxWindow *) 0 ;
39490 wxPoint *arg2 = 0 ;
39491 wxPoint result;
39492 void *argp1 = 0 ;
39493 int res1 = 0 ;
39494 wxPoint temp2 ;
39495 PyObject * obj0 = 0 ;
39496 PyObject * obj1 = 0 ;
39497 char * kwnames[] = {
39498 (char *) "self",(char *) "pt", NULL
39499 };
39500
39501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39503 if (!SWIG_IsOK(res1)) {
39504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39505 }
39506 arg1 = reinterpret_cast< wxWindow * >(argp1);
39507 {
39508 arg2 = &temp2;
39509 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39510 }
39511 {
39512 PyThreadState* __tstate = wxPyBeginAllowThreads();
39513 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39514 wxPyEndAllowThreads(__tstate);
39515 if (PyErr_Occurred()) SWIG_fail;
39516 }
39517 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39518 return resultobj;
39519 fail:
39520 return NULL;
39521 }
39522
39523
39524 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39525 PyObject *resultobj = 0;
39526 wxWindow *arg1 = (wxWindow *) 0 ;
39527 wxPoint *arg2 = 0 ;
39528 wxPoint result;
39529 void *argp1 = 0 ;
39530 int res1 = 0 ;
39531 wxPoint temp2 ;
39532 PyObject * obj0 = 0 ;
39533 PyObject * obj1 = 0 ;
39534 char * kwnames[] = {
39535 (char *) "self",(char *) "pt", NULL
39536 };
39537
39538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39540 if (!SWIG_IsOK(res1)) {
39541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39542 }
39543 arg1 = reinterpret_cast< wxWindow * >(argp1);
39544 {
39545 arg2 = &temp2;
39546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39547 }
39548 {
39549 PyThreadState* __tstate = wxPyBeginAllowThreads();
39550 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39551 wxPyEndAllowThreads(__tstate);
39552 if (PyErr_Occurred()) SWIG_fail;
39553 }
39554 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39555 return resultobj;
39556 fail:
39557 return NULL;
39558 }
39559
39560
39561 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39562 PyObject *resultobj = 0;
39563 wxWindow *arg1 = (wxWindow *) 0 ;
39564 int arg2 ;
39565 int arg3 ;
39566 wxHitTest result;
39567 void *argp1 = 0 ;
39568 int res1 = 0 ;
39569 int val2 ;
39570 int ecode2 = 0 ;
39571 int val3 ;
39572 int ecode3 = 0 ;
39573 PyObject * obj0 = 0 ;
39574 PyObject * obj1 = 0 ;
39575 PyObject * obj2 = 0 ;
39576 char * kwnames[] = {
39577 (char *) "self",(char *) "x",(char *) "y", NULL
39578 };
39579
39580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39582 if (!SWIG_IsOK(res1)) {
39583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39584 }
39585 arg1 = reinterpret_cast< wxWindow * >(argp1);
39586 ecode2 = SWIG_AsVal_int(obj1, &val2);
39587 if (!SWIG_IsOK(ecode2)) {
39588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39589 }
39590 arg2 = static_cast< int >(val2);
39591 ecode3 = SWIG_AsVal_int(obj2, &val3);
39592 if (!SWIG_IsOK(ecode3)) {
39593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39594 }
39595 arg3 = static_cast< int >(val3);
39596 {
39597 PyThreadState* __tstate = wxPyBeginAllowThreads();
39598 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39599 wxPyEndAllowThreads(__tstate);
39600 if (PyErr_Occurred()) SWIG_fail;
39601 }
39602 resultobj = SWIG_From_int(static_cast< int >(result));
39603 return resultobj;
39604 fail:
39605 return NULL;
39606 }
39607
39608
39609 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39610 PyObject *resultobj = 0;
39611 wxWindow *arg1 = (wxWindow *) 0 ;
39612 wxPoint *arg2 = 0 ;
39613 wxHitTest result;
39614 void *argp1 = 0 ;
39615 int res1 = 0 ;
39616 wxPoint temp2 ;
39617 PyObject * obj0 = 0 ;
39618 PyObject * obj1 = 0 ;
39619 char * kwnames[] = {
39620 (char *) "self",(char *) "pt", NULL
39621 };
39622
39623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39625 if (!SWIG_IsOK(res1)) {
39626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39627 }
39628 arg1 = reinterpret_cast< wxWindow * >(argp1);
39629 {
39630 arg2 = &temp2;
39631 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39632 }
39633 {
39634 PyThreadState* __tstate = wxPyBeginAllowThreads();
39635 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39636 wxPyEndAllowThreads(__tstate);
39637 if (PyErr_Occurred()) SWIG_fail;
39638 }
39639 resultobj = SWIG_From_int(static_cast< int >(result));
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39647 PyObject *resultobj = 0;
39648 wxWindow *arg1 = (wxWindow *) 0 ;
39649 long arg2 ;
39650 wxBorder result;
39651 void *argp1 = 0 ;
39652 int res1 = 0 ;
39653 long val2 ;
39654 int ecode2 = 0 ;
39655
39656 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39658 if (!SWIG_IsOK(res1)) {
39659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39660 }
39661 arg1 = reinterpret_cast< wxWindow * >(argp1);
39662 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39663 if (!SWIG_IsOK(ecode2)) {
39664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39665 }
39666 arg2 = static_cast< long >(val2);
39667 {
39668 PyThreadState* __tstate = wxPyBeginAllowThreads();
39669 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39670 wxPyEndAllowThreads(__tstate);
39671 if (PyErr_Occurred()) SWIG_fail;
39672 }
39673 resultobj = SWIG_From_int(static_cast< int >(result));
39674 return resultobj;
39675 fail:
39676 return NULL;
39677 }
39678
39679
39680 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39681 PyObject *resultobj = 0;
39682 wxWindow *arg1 = (wxWindow *) 0 ;
39683 wxBorder result;
39684 void *argp1 = 0 ;
39685 int res1 = 0 ;
39686
39687 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39689 if (!SWIG_IsOK(res1)) {
39690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39691 }
39692 arg1 = reinterpret_cast< wxWindow * >(argp1);
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39696 wxPyEndAllowThreads(__tstate);
39697 if (PyErr_Occurred()) SWIG_fail;
39698 }
39699 resultobj = SWIG_From_int(static_cast< int >(result));
39700 return resultobj;
39701 fail:
39702 return NULL;
39703 }
39704
39705
39706 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39707 int argc;
39708 PyObject *argv[3];
39709
39710 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39711 --argc;
39712 if (argc == 1) {
39713 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39714 }
39715 if (argc == 2) {
39716 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39717 }
39718
39719 fail:
39720 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39721 return NULL;
39722 }
39723
39724
39725 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39726 PyObject *resultobj = 0;
39727 wxWindow *arg1 = (wxWindow *) 0 ;
39728 long arg2 = (long) wxUPDATE_UI_NONE ;
39729 void *argp1 = 0 ;
39730 int res1 = 0 ;
39731 long val2 ;
39732 int ecode2 = 0 ;
39733 PyObject * obj0 = 0 ;
39734 PyObject * obj1 = 0 ;
39735 char * kwnames[] = {
39736 (char *) "self",(char *) "flags", NULL
39737 };
39738
39739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39741 if (!SWIG_IsOK(res1)) {
39742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39743 }
39744 arg1 = reinterpret_cast< wxWindow * >(argp1);
39745 if (obj1) {
39746 ecode2 = SWIG_AsVal_long(obj1, &val2);
39747 if (!SWIG_IsOK(ecode2)) {
39748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39749 }
39750 arg2 = static_cast< long >(val2);
39751 }
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 (arg1)->UpdateWindowUI(arg2);
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 resultobj = SWIG_Py_Void();
39759 return resultobj;
39760 fail:
39761 return NULL;
39762 }
39763
39764
39765 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39766 PyObject *resultobj = 0;
39767 wxWindow *arg1 = (wxWindow *) 0 ;
39768 wxMenu *arg2 = (wxMenu *) 0 ;
39769 int arg3 = (int) -1 ;
39770 int arg4 = (int) -1 ;
39771 bool result;
39772 void *argp1 = 0 ;
39773 int res1 = 0 ;
39774 void *argp2 = 0 ;
39775 int res2 = 0 ;
39776 int val3 ;
39777 int ecode3 = 0 ;
39778 int val4 ;
39779 int ecode4 = 0 ;
39780 PyObject * obj0 = 0 ;
39781 PyObject * obj1 = 0 ;
39782 PyObject * obj2 = 0 ;
39783 PyObject * obj3 = 0 ;
39784 char * kwnames[] = {
39785 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39786 };
39787
39788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39790 if (!SWIG_IsOK(res1)) {
39791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39792 }
39793 arg1 = reinterpret_cast< wxWindow * >(argp1);
39794 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39795 if (!SWIG_IsOK(res2)) {
39796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39797 }
39798 arg2 = reinterpret_cast< wxMenu * >(argp2);
39799 if (obj2) {
39800 ecode3 = SWIG_AsVal_int(obj2, &val3);
39801 if (!SWIG_IsOK(ecode3)) {
39802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39803 }
39804 arg3 = static_cast< int >(val3);
39805 }
39806 if (obj3) {
39807 ecode4 = SWIG_AsVal_int(obj3, &val4);
39808 if (!SWIG_IsOK(ecode4)) {
39809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39810 }
39811 arg4 = static_cast< int >(val4);
39812 }
39813 {
39814 PyThreadState* __tstate = wxPyBeginAllowThreads();
39815 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 {
39820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39821 }
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj = 0;
39830 wxWindow *arg1 = (wxWindow *) 0 ;
39831 wxMenu *arg2 = (wxMenu *) 0 ;
39832 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39833 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39834 bool result;
39835 void *argp1 = 0 ;
39836 int res1 = 0 ;
39837 void *argp2 = 0 ;
39838 int res2 = 0 ;
39839 wxPoint temp3 ;
39840 PyObject * obj0 = 0 ;
39841 PyObject * obj1 = 0 ;
39842 PyObject * obj2 = 0 ;
39843 char * kwnames[] = {
39844 (char *) "self",(char *) "menu",(char *) "pos", NULL
39845 };
39846
39847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39849 if (!SWIG_IsOK(res1)) {
39850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39851 }
39852 arg1 = reinterpret_cast< wxWindow * >(argp1);
39853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39854 if (!SWIG_IsOK(res2)) {
39855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39856 }
39857 arg2 = reinterpret_cast< wxMenu * >(argp2);
39858 if (obj2) {
39859 {
39860 arg3 = &temp3;
39861 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39862 }
39863 }
39864 {
39865 PyThreadState* __tstate = wxPyBeginAllowThreads();
39866 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39867 wxPyEndAllowThreads(__tstate);
39868 if (PyErr_Occurred()) SWIG_fail;
39869 }
39870 {
39871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39872 }
39873 return resultobj;
39874 fail:
39875 return NULL;
39876 }
39877
39878
39879 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39880 PyObject *resultobj = 0;
39881 wxWindow *arg1 = (wxWindow *) 0 ;
39882 bool result;
39883 void *argp1 = 0 ;
39884 int res1 = 0 ;
39885 PyObject *swig_obj[1] ;
39886
39887 if (!args) SWIG_fail;
39888 swig_obj[0] = args;
39889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39890 if (!SWIG_IsOK(res1)) {
39891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39892 }
39893 arg1 = reinterpret_cast< wxWindow * >(argp1);
39894 {
39895 PyThreadState* __tstate = wxPyBeginAllowThreads();
39896 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 {
39901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39902 }
39903 return resultobj;
39904 fail:
39905 return NULL;
39906 }
39907
39908
39909 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39910 PyObject *resultobj = 0;
39911 wxWindow *arg1 = (wxWindow *) 0 ;
39912 long result;
39913 void *argp1 = 0 ;
39914 int res1 = 0 ;
39915 PyObject *swig_obj[1] ;
39916
39917 if (!args) SWIG_fail;
39918 swig_obj[0] = args;
39919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39920 if (!SWIG_IsOK(res1)) {
39921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39922 }
39923 arg1 = reinterpret_cast< wxWindow * >(argp1);
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 result = (long)wxWindow_GetHandle(arg1);
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 resultobj = SWIG_From_long(static_cast< long >(result));
39931 return resultobj;
39932 fail:
39933 return NULL;
39934 }
39935
39936
39937 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39938 PyObject *resultobj = 0;
39939 wxWindow *arg1 = (wxWindow *) 0 ;
39940 long arg2 ;
39941 void *argp1 = 0 ;
39942 int res1 = 0 ;
39943 long val2 ;
39944 int ecode2 = 0 ;
39945 PyObject * obj0 = 0 ;
39946 PyObject * obj1 = 0 ;
39947 char * kwnames[] = {
39948 (char *) "self",(char *) "handle", NULL
39949 };
39950
39951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39953 if (!SWIG_IsOK(res1)) {
39954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39955 }
39956 arg1 = reinterpret_cast< wxWindow * >(argp1);
39957 ecode2 = SWIG_AsVal_long(obj1, &val2);
39958 if (!SWIG_IsOK(ecode2)) {
39959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39960 }
39961 arg2 = static_cast< long >(val2);
39962 {
39963 PyThreadState* __tstate = wxPyBeginAllowThreads();
39964 wxWindow_AssociateHandle(arg1,arg2);
39965 wxPyEndAllowThreads(__tstate);
39966 if (PyErr_Occurred()) SWIG_fail;
39967 }
39968 resultobj = SWIG_Py_Void();
39969 return resultobj;
39970 fail:
39971 return NULL;
39972 }
39973
39974
39975 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39976 PyObject *resultobj = 0;
39977 wxWindow *arg1 = (wxWindow *) 0 ;
39978 void *argp1 = 0 ;
39979 int res1 = 0 ;
39980 PyObject *swig_obj[1] ;
39981
39982 if (!args) SWIG_fail;
39983 swig_obj[0] = args;
39984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39985 if (!SWIG_IsOK(res1)) {
39986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39987 }
39988 arg1 = reinterpret_cast< wxWindow * >(argp1);
39989 {
39990 PyThreadState* __tstate = wxPyBeginAllowThreads();
39991 (arg1)->DissociateHandle();
39992 wxPyEndAllowThreads(__tstate);
39993 if (PyErr_Occurred()) SWIG_fail;
39994 }
39995 resultobj = SWIG_Py_Void();
39996 return resultobj;
39997 fail:
39998 return NULL;
39999 }
40000
40001
40002 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40003 PyObject *resultobj = 0;
40004 wxWindow *arg1 = (wxWindow *) 0 ;
40005 int arg2 ;
40006 bool result;
40007 void *argp1 = 0 ;
40008 int res1 = 0 ;
40009 int val2 ;
40010 int ecode2 = 0 ;
40011 PyObject * obj0 = 0 ;
40012 PyObject * obj1 = 0 ;
40013 char * kwnames[] = {
40014 (char *) "self",(char *) "orient", NULL
40015 };
40016
40017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40019 if (!SWIG_IsOK(res1)) {
40020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40021 }
40022 arg1 = reinterpret_cast< wxWindow * >(argp1);
40023 ecode2 = SWIG_AsVal_int(obj1, &val2);
40024 if (!SWIG_IsOK(ecode2)) {
40025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40026 }
40027 arg2 = static_cast< int >(val2);
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40031 wxPyEndAllowThreads(__tstate);
40032 if (PyErr_Occurred()) SWIG_fail;
40033 }
40034 {
40035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40036 }
40037 return resultobj;
40038 fail:
40039 return NULL;
40040 }
40041
40042
40043 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj = 0;
40045 wxWindow *arg1 = (wxWindow *) 0 ;
40046 int arg2 ;
40047 int arg3 ;
40048 int arg4 ;
40049 int arg5 ;
40050 bool arg6 = (bool) true ;
40051 void *argp1 = 0 ;
40052 int res1 = 0 ;
40053 int val2 ;
40054 int ecode2 = 0 ;
40055 int val3 ;
40056 int ecode3 = 0 ;
40057 int val4 ;
40058 int ecode4 = 0 ;
40059 int val5 ;
40060 int ecode5 = 0 ;
40061 bool val6 ;
40062 int ecode6 = 0 ;
40063 PyObject * obj0 = 0 ;
40064 PyObject * obj1 = 0 ;
40065 PyObject * obj2 = 0 ;
40066 PyObject * obj3 = 0 ;
40067 PyObject * obj4 = 0 ;
40068 PyObject * obj5 = 0 ;
40069 char * kwnames[] = {
40070 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40071 };
40072
40073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40075 if (!SWIG_IsOK(res1)) {
40076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40077 }
40078 arg1 = reinterpret_cast< wxWindow * >(argp1);
40079 ecode2 = SWIG_AsVal_int(obj1, &val2);
40080 if (!SWIG_IsOK(ecode2)) {
40081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40082 }
40083 arg2 = static_cast< int >(val2);
40084 ecode3 = SWIG_AsVal_int(obj2, &val3);
40085 if (!SWIG_IsOK(ecode3)) {
40086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40087 }
40088 arg3 = static_cast< int >(val3);
40089 ecode4 = SWIG_AsVal_int(obj3, &val4);
40090 if (!SWIG_IsOK(ecode4)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40092 }
40093 arg4 = static_cast< int >(val4);
40094 ecode5 = SWIG_AsVal_int(obj4, &val5);
40095 if (!SWIG_IsOK(ecode5)) {
40096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40097 }
40098 arg5 = static_cast< int >(val5);
40099 if (obj5) {
40100 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40101 if (!SWIG_IsOK(ecode6)) {
40102 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40103 }
40104 arg6 = static_cast< bool >(val6);
40105 }
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 resultobj = SWIG_Py_Void();
40113 return resultobj;
40114 fail:
40115 return NULL;
40116 }
40117
40118
40119 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40120 PyObject *resultobj = 0;
40121 wxWindow *arg1 = (wxWindow *) 0 ;
40122 int arg2 ;
40123 int arg3 ;
40124 bool arg4 = (bool) true ;
40125 void *argp1 = 0 ;
40126 int res1 = 0 ;
40127 int val2 ;
40128 int ecode2 = 0 ;
40129 int val3 ;
40130 int ecode3 = 0 ;
40131 bool val4 ;
40132 int ecode4 = 0 ;
40133 PyObject * obj0 = 0 ;
40134 PyObject * obj1 = 0 ;
40135 PyObject * obj2 = 0 ;
40136 PyObject * obj3 = 0 ;
40137 char * kwnames[] = {
40138 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40139 };
40140
40141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40143 if (!SWIG_IsOK(res1)) {
40144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40145 }
40146 arg1 = reinterpret_cast< wxWindow * >(argp1);
40147 ecode2 = SWIG_AsVal_int(obj1, &val2);
40148 if (!SWIG_IsOK(ecode2)) {
40149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40150 }
40151 arg2 = static_cast< int >(val2);
40152 ecode3 = SWIG_AsVal_int(obj2, &val3);
40153 if (!SWIG_IsOK(ecode3)) {
40154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40155 }
40156 arg3 = static_cast< int >(val3);
40157 if (obj3) {
40158 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40159 if (!SWIG_IsOK(ecode4)) {
40160 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40161 }
40162 arg4 = static_cast< bool >(val4);
40163 }
40164 {
40165 PyThreadState* __tstate = wxPyBeginAllowThreads();
40166 (arg1)->SetScrollPos(arg2,arg3,arg4);
40167 wxPyEndAllowThreads(__tstate);
40168 if (PyErr_Occurred()) SWIG_fail;
40169 }
40170 resultobj = SWIG_Py_Void();
40171 return resultobj;
40172 fail:
40173 return NULL;
40174 }
40175
40176
40177 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40178 PyObject *resultobj = 0;
40179 wxWindow *arg1 = (wxWindow *) 0 ;
40180 int arg2 ;
40181 int result;
40182 void *argp1 = 0 ;
40183 int res1 = 0 ;
40184 int val2 ;
40185 int ecode2 = 0 ;
40186 PyObject * obj0 = 0 ;
40187 PyObject * obj1 = 0 ;
40188 char * kwnames[] = {
40189 (char *) "self",(char *) "orientation", NULL
40190 };
40191
40192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40194 if (!SWIG_IsOK(res1)) {
40195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40196 }
40197 arg1 = reinterpret_cast< wxWindow * >(argp1);
40198 ecode2 = SWIG_AsVal_int(obj1, &val2);
40199 if (!SWIG_IsOK(ecode2)) {
40200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40201 }
40202 arg2 = static_cast< int >(val2);
40203 {
40204 PyThreadState* __tstate = wxPyBeginAllowThreads();
40205 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40206 wxPyEndAllowThreads(__tstate);
40207 if (PyErr_Occurred()) SWIG_fail;
40208 }
40209 resultobj = SWIG_From_int(static_cast< int >(result));
40210 return resultobj;
40211 fail:
40212 return NULL;
40213 }
40214
40215
40216 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40217 PyObject *resultobj = 0;
40218 wxWindow *arg1 = (wxWindow *) 0 ;
40219 int arg2 ;
40220 int result;
40221 void *argp1 = 0 ;
40222 int res1 = 0 ;
40223 int val2 ;
40224 int ecode2 = 0 ;
40225 PyObject * obj0 = 0 ;
40226 PyObject * obj1 = 0 ;
40227 char * kwnames[] = {
40228 (char *) "self",(char *) "orientation", NULL
40229 };
40230
40231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40233 if (!SWIG_IsOK(res1)) {
40234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40235 }
40236 arg1 = reinterpret_cast< wxWindow * >(argp1);
40237 ecode2 = SWIG_AsVal_int(obj1, &val2);
40238 if (!SWIG_IsOK(ecode2)) {
40239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40240 }
40241 arg2 = static_cast< int >(val2);
40242 {
40243 PyThreadState* __tstate = wxPyBeginAllowThreads();
40244 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 resultobj = SWIG_From_int(static_cast< int >(result));
40249 return resultobj;
40250 fail:
40251 return NULL;
40252 }
40253
40254
40255 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40256 PyObject *resultobj = 0;
40257 wxWindow *arg1 = (wxWindow *) 0 ;
40258 int arg2 ;
40259 int result;
40260 void *argp1 = 0 ;
40261 int res1 = 0 ;
40262 int val2 ;
40263 int ecode2 = 0 ;
40264 PyObject * obj0 = 0 ;
40265 PyObject * obj1 = 0 ;
40266 char * kwnames[] = {
40267 (char *) "self",(char *) "orientation", NULL
40268 };
40269
40270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40272 if (!SWIG_IsOK(res1)) {
40273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40274 }
40275 arg1 = reinterpret_cast< wxWindow * >(argp1);
40276 ecode2 = SWIG_AsVal_int(obj1, &val2);
40277 if (!SWIG_IsOK(ecode2)) {
40278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40279 }
40280 arg2 = static_cast< int >(val2);
40281 {
40282 PyThreadState* __tstate = wxPyBeginAllowThreads();
40283 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40284 wxPyEndAllowThreads(__tstate);
40285 if (PyErr_Occurred()) SWIG_fail;
40286 }
40287 resultobj = SWIG_From_int(static_cast< int >(result));
40288 return resultobj;
40289 fail:
40290 return NULL;
40291 }
40292
40293
40294 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40295 PyObject *resultobj = 0;
40296 wxWindow *arg1 = (wxWindow *) 0 ;
40297 int arg2 ;
40298 int arg3 ;
40299 wxRect *arg4 = (wxRect *) NULL ;
40300 void *argp1 = 0 ;
40301 int res1 = 0 ;
40302 int val2 ;
40303 int ecode2 = 0 ;
40304 int val3 ;
40305 int ecode3 = 0 ;
40306 void *argp4 = 0 ;
40307 int res4 = 0 ;
40308 PyObject * obj0 = 0 ;
40309 PyObject * obj1 = 0 ;
40310 PyObject * obj2 = 0 ;
40311 PyObject * obj3 = 0 ;
40312 char * kwnames[] = {
40313 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40314 };
40315
40316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40318 if (!SWIG_IsOK(res1)) {
40319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40320 }
40321 arg1 = reinterpret_cast< wxWindow * >(argp1);
40322 ecode2 = SWIG_AsVal_int(obj1, &val2);
40323 if (!SWIG_IsOK(ecode2)) {
40324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40325 }
40326 arg2 = static_cast< int >(val2);
40327 ecode3 = SWIG_AsVal_int(obj2, &val3);
40328 if (!SWIG_IsOK(ecode3)) {
40329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40330 }
40331 arg3 = static_cast< int >(val3);
40332 if (obj3) {
40333 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40334 if (!SWIG_IsOK(res4)) {
40335 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40336 }
40337 arg4 = reinterpret_cast< wxRect * >(argp4);
40338 }
40339 {
40340 PyThreadState* __tstate = wxPyBeginAllowThreads();
40341 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 resultobj = SWIG_Py_Void();
40346 return resultobj;
40347 fail:
40348 return NULL;
40349 }
40350
40351
40352 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40353 PyObject *resultobj = 0;
40354 wxWindow *arg1 = (wxWindow *) 0 ;
40355 int arg2 ;
40356 bool result;
40357 void *argp1 = 0 ;
40358 int res1 = 0 ;
40359 int val2 ;
40360 int ecode2 = 0 ;
40361 PyObject * obj0 = 0 ;
40362 PyObject * obj1 = 0 ;
40363 char * kwnames[] = {
40364 (char *) "self",(char *) "lines", NULL
40365 };
40366
40367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40369 if (!SWIG_IsOK(res1)) {
40370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40371 }
40372 arg1 = reinterpret_cast< wxWindow * >(argp1);
40373 ecode2 = SWIG_AsVal_int(obj1, &val2);
40374 if (!SWIG_IsOK(ecode2)) {
40375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40376 }
40377 arg2 = static_cast< int >(val2);
40378 {
40379 PyThreadState* __tstate = wxPyBeginAllowThreads();
40380 result = (bool)(arg1)->ScrollLines(arg2);
40381 wxPyEndAllowThreads(__tstate);
40382 if (PyErr_Occurred()) SWIG_fail;
40383 }
40384 {
40385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40386 }
40387 return resultobj;
40388 fail:
40389 return NULL;
40390 }
40391
40392
40393 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40394 PyObject *resultobj = 0;
40395 wxWindow *arg1 = (wxWindow *) 0 ;
40396 int arg2 ;
40397 bool result;
40398 void *argp1 = 0 ;
40399 int res1 = 0 ;
40400 int val2 ;
40401 int ecode2 = 0 ;
40402 PyObject * obj0 = 0 ;
40403 PyObject * obj1 = 0 ;
40404 char * kwnames[] = {
40405 (char *) "self",(char *) "pages", NULL
40406 };
40407
40408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40410 if (!SWIG_IsOK(res1)) {
40411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40412 }
40413 arg1 = reinterpret_cast< wxWindow * >(argp1);
40414 ecode2 = SWIG_AsVal_int(obj1, &val2);
40415 if (!SWIG_IsOK(ecode2)) {
40416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40417 }
40418 arg2 = static_cast< int >(val2);
40419 {
40420 PyThreadState* __tstate = wxPyBeginAllowThreads();
40421 result = (bool)(arg1)->ScrollPages(arg2);
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 {
40426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40427 }
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40435 PyObject *resultobj = 0;
40436 wxWindow *arg1 = (wxWindow *) 0 ;
40437 bool result;
40438 void *argp1 = 0 ;
40439 int res1 = 0 ;
40440 PyObject *swig_obj[1] ;
40441
40442 if (!args) SWIG_fail;
40443 swig_obj[0] = args;
40444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40445 if (!SWIG_IsOK(res1)) {
40446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40447 }
40448 arg1 = reinterpret_cast< wxWindow * >(argp1);
40449 {
40450 PyThreadState* __tstate = wxPyBeginAllowThreads();
40451 result = (bool)(arg1)->LineUp();
40452 wxPyEndAllowThreads(__tstate);
40453 if (PyErr_Occurred()) SWIG_fail;
40454 }
40455 {
40456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40457 }
40458 return resultobj;
40459 fail:
40460 return NULL;
40461 }
40462
40463
40464 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40465 PyObject *resultobj = 0;
40466 wxWindow *arg1 = (wxWindow *) 0 ;
40467 bool result;
40468 void *argp1 = 0 ;
40469 int res1 = 0 ;
40470 PyObject *swig_obj[1] ;
40471
40472 if (!args) SWIG_fail;
40473 swig_obj[0] = args;
40474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40475 if (!SWIG_IsOK(res1)) {
40476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40477 }
40478 arg1 = reinterpret_cast< wxWindow * >(argp1);
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 result = (bool)(arg1)->LineDown();
40482 wxPyEndAllowThreads(__tstate);
40483 if (PyErr_Occurred()) SWIG_fail;
40484 }
40485 {
40486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40487 }
40488 return resultobj;
40489 fail:
40490 return NULL;
40491 }
40492
40493
40494 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40495 PyObject *resultobj = 0;
40496 wxWindow *arg1 = (wxWindow *) 0 ;
40497 bool result;
40498 void *argp1 = 0 ;
40499 int res1 = 0 ;
40500 PyObject *swig_obj[1] ;
40501
40502 if (!args) SWIG_fail;
40503 swig_obj[0] = args;
40504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40505 if (!SWIG_IsOK(res1)) {
40506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40507 }
40508 arg1 = reinterpret_cast< wxWindow * >(argp1);
40509 {
40510 PyThreadState* __tstate = wxPyBeginAllowThreads();
40511 result = (bool)(arg1)->PageUp();
40512 wxPyEndAllowThreads(__tstate);
40513 if (PyErr_Occurred()) SWIG_fail;
40514 }
40515 {
40516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40517 }
40518 return resultobj;
40519 fail:
40520 return NULL;
40521 }
40522
40523
40524 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40525 PyObject *resultobj = 0;
40526 wxWindow *arg1 = (wxWindow *) 0 ;
40527 bool result;
40528 void *argp1 = 0 ;
40529 int res1 = 0 ;
40530 PyObject *swig_obj[1] ;
40531
40532 if (!args) SWIG_fail;
40533 swig_obj[0] = args;
40534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40535 if (!SWIG_IsOK(res1)) {
40536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40537 }
40538 arg1 = reinterpret_cast< wxWindow * >(argp1);
40539 {
40540 PyThreadState* __tstate = wxPyBeginAllowThreads();
40541 result = (bool)(arg1)->PageDown();
40542 wxPyEndAllowThreads(__tstate);
40543 if (PyErr_Occurred()) SWIG_fail;
40544 }
40545 {
40546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40547 }
40548 return resultobj;
40549 fail:
40550 return NULL;
40551 }
40552
40553
40554 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40555 PyObject *resultobj = 0;
40556 wxWindow *arg1 = (wxWindow *) 0 ;
40557 wxString *arg2 = 0 ;
40558 void *argp1 = 0 ;
40559 int res1 = 0 ;
40560 bool temp2 = false ;
40561 PyObject * obj0 = 0 ;
40562 PyObject * obj1 = 0 ;
40563 char * kwnames[] = {
40564 (char *) "self",(char *) "text", NULL
40565 };
40566
40567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40569 if (!SWIG_IsOK(res1)) {
40570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40571 }
40572 arg1 = reinterpret_cast< wxWindow * >(argp1);
40573 {
40574 arg2 = wxString_in_helper(obj1);
40575 if (arg2 == NULL) SWIG_fail;
40576 temp2 = true;
40577 }
40578 {
40579 PyThreadState* __tstate = wxPyBeginAllowThreads();
40580 (arg1)->SetHelpText((wxString const &)*arg2);
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 resultobj = SWIG_Py_Void();
40585 {
40586 if (temp2)
40587 delete arg2;
40588 }
40589 return resultobj;
40590 fail:
40591 {
40592 if (temp2)
40593 delete arg2;
40594 }
40595 return NULL;
40596 }
40597
40598
40599 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40600 PyObject *resultobj = 0;
40601 wxWindow *arg1 = (wxWindow *) 0 ;
40602 wxString *arg2 = 0 ;
40603 void *argp1 = 0 ;
40604 int res1 = 0 ;
40605 bool temp2 = false ;
40606 PyObject * obj0 = 0 ;
40607 PyObject * obj1 = 0 ;
40608 char * kwnames[] = {
40609 (char *) "self",(char *) "text", NULL
40610 };
40611
40612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40614 if (!SWIG_IsOK(res1)) {
40615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40616 }
40617 arg1 = reinterpret_cast< wxWindow * >(argp1);
40618 {
40619 arg2 = wxString_in_helper(obj1);
40620 if (arg2 == NULL) SWIG_fail;
40621 temp2 = true;
40622 }
40623 {
40624 PyThreadState* __tstate = wxPyBeginAllowThreads();
40625 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40626 wxPyEndAllowThreads(__tstate);
40627 if (PyErr_Occurred()) SWIG_fail;
40628 }
40629 resultobj = SWIG_Py_Void();
40630 {
40631 if (temp2)
40632 delete arg2;
40633 }
40634 return resultobj;
40635 fail:
40636 {
40637 if (temp2)
40638 delete arg2;
40639 }
40640 return NULL;
40641 }
40642
40643
40644 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40645 PyObject *resultobj = 0;
40646 wxWindow *arg1 = (wxWindow *) 0 ;
40647 wxPoint *arg2 = 0 ;
40648 wxHelpEvent::Origin arg3 ;
40649 wxString result;
40650 void *argp1 = 0 ;
40651 int res1 = 0 ;
40652 wxPoint temp2 ;
40653 void *argp3 ;
40654 int res3 = 0 ;
40655 PyObject * obj0 = 0 ;
40656 PyObject * obj1 = 0 ;
40657 PyObject * obj2 = 0 ;
40658 char * kwnames[] = {
40659 (char *) "self",(char *) "pt",(char *) "origin", NULL
40660 };
40661
40662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40664 if (!SWIG_IsOK(res1)) {
40665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40666 }
40667 arg1 = reinterpret_cast< wxWindow * >(argp1);
40668 {
40669 arg2 = &temp2;
40670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40671 }
40672 {
40673 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40674 if (!SWIG_IsOK(res3)) {
40675 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40676 }
40677 if (!argp3) {
40678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40679 } else {
40680 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40681 arg3 = *temp;
40682 if (SWIG_IsNewObj(res3)) delete temp;
40683 }
40684 }
40685 {
40686 PyThreadState* __tstate = wxPyBeginAllowThreads();
40687 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40688 wxPyEndAllowThreads(__tstate);
40689 if (PyErr_Occurred()) SWIG_fail;
40690 }
40691 {
40692 #if wxUSE_UNICODE
40693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40694 #else
40695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40696 #endif
40697 }
40698 return resultobj;
40699 fail:
40700 return NULL;
40701 }
40702
40703
40704 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40705 PyObject *resultobj = 0;
40706 wxWindow *arg1 = (wxWindow *) 0 ;
40707 wxString result;
40708 void *argp1 = 0 ;
40709 int res1 = 0 ;
40710 PyObject *swig_obj[1] ;
40711
40712 if (!args) SWIG_fail;
40713 swig_obj[0] = args;
40714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40715 if (!SWIG_IsOK(res1)) {
40716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40717 }
40718 arg1 = reinterpret_cast< wxWindow * >(argp1);
40719 {
40720 PyThreadState* __tstate = wxPyBeginAllowThreads();
40721 result = ((wxWindow const *)arg1)->GetHelpText();
40722 wxPyEndAllowThreads(__tstate);
40723 if (PyErr_Occurred()) SWIG_fail;
40724 }
40725 {
40726 #if wxUSE_UNICODE
40727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40728 #else
40729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40730 #endif
40731 }
40732 return resultobj;
40733 fail:
40734 return NULL;
40735 }
40736
40737
40738 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40739 PyObject *resultobj = 0;
40740 wxWindow *arg1 = (wxWindow *) 0 ;
40741 wxString *arg2 = 0 ;
40742 void *argp1 = 0 ;
40743 int res1 = 0 ;
40744 bool temp2 = false ;
40745 PyObject * obj0 = 0 ;
40746 PyObject * obj1 = 0 ;
40747 char * kwnames[] = {
40748 (char *) "self",(char *) "tip", NULL
40749 };
40750
40751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40753 if (!SWIG_IsOK(res1)) {
40754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40755 }
40756 arg1 = reinterpret_cast< wxWindow * >(argp1);
40757 {
40758 arg2 = wxString_in_helper(obj1);
40759 if (arg2 == NULL) SWIG_fail;
40760 temp2 = true;
40761 }
40762 {
40763 PyThreadState* __tstate = wxPyBeginAllowThreads();
40764 (arg1)->SetToolTip((wxString const &)*arg2);
40765 wxPyEndAllowThreads(__tstate);
40766 if (PyErr_Occurred()) SWIG_fail;
40767 }
40768 resultobj = SWIG_Py_Void();
40769 {
40770 if (temp2)
40771 delete arg2;
40772 }
40773 return resultobj;
40774 fail:
40775 {
40776 if (temp2)
40777 delete arg2;
40778 }
40779 return NULL;
40780 }
40781
40782
40783 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40784 PyObject *resultobj = 0;
40785 wxWindow *arg1 = (wxWindow *) 0 ;
40786 wxToolTip *arg2 = (wxToolTip *) 0 ;
40787 void *argp1 = 0 ;
40788 int res1 = 0 ;
40789 int res2 = 0 ;
40790 PyObject * obj0 = 0 ;
40791 PyObject * obj1 = 0 ;
40792 char * kwnames[] = {
40793 (char *) "self",(char *) "tip", NULL
40794 };
40795
40796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40798 if (!SWIG_IsOK(res1)) {
40799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40800 }
40801 arg1 = reinterpret_cast< wxWindow * >(argp1);
40802 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40803 if (!SWIG_IsOK(res2)) {
40804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40805 }
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 (arg1)->SetToolTip(arg2);
40809 wxPyEndAllowThreads(__tstate);
40810 if (PyErr_Occurred()) SWIG_fail;
40811 }
40812 resultobj = SWIG_Py_Void();
40813 return resultobj;
40814 fail:
40815 return NULL;
40816 }
40817
40818
40819 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40820 PyObject *resultobj = 0;
40821 wxWindow *arg1 = (wxWindow *) 0 ;
40822 wxToolTip *result = 0 ;
40823 void *argp1 = 0 ;
40824 int res1 = 0 ;
40825 PyObject *swig_obj[1] ;
40826
40827 if (!args) SWIG_fail;
40828 swig_obj[0] = args;
40829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40830 if (!SWIG_IsOK(res1)) {
40831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40832 }
40833 arg1 = reinterpret_cast< wxWindow * >(argp1);
40834 {
40835 PyThreadState* __tstate = wxPyBeginAllowThreads();
40836 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40837 wxPyEndAllowThreads(__tstate);
40838 if (PyErr_Occurred()) SWIG_fail;
40839 }
40840 {
40841 resultobj = wxPyMake_wxObject(result, (bool)0);
40842 }
40843 return resultobj;
40844 fail:
40845 return NULL;
40846 }
40847
40848
40849 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40850 PyObject *resultobj = 0;
40851 wxWindow *arg1 = (wxWindow *) 0 ;
40852 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40853 void *argp1 = 0 ;
40854 int res1 = 0 ;
40855 int res2 = 0 ;
40856 PyObject * obj0 = 0 ;
40857 PyObject * obj1 = 0 ;
40858 char * kwnames[] = {
40859 (char *) "self",(char *) "dropTarget", NULL
40860 };
40861
40862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40864 if (!SWIG_IsOK(res1)) {
40865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40866 }
40867 arg1 = reinterpret_cast< wxWindow * >(argp1);
40868 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40869 if (!SWIG_IsOK(res2)) {
40870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40871 }
40872 {
40873 PyThreadState* __tstate = wxPyBeginAllowThreads();
40874 (arg1)->SetDropTarget(arg2);
40875 wxPyEndAllowThreads(__tstate);
40876 if (PyErr_Occurred()) SWIG_fail;
40877 }
40878 resultobj = SWIG_Py_Void();
40879 return resultobj;
40880 fail:
40881 return NULL;
40882 }
40883
40884
40885 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40886 PyObject *resultobj = 0;
40887 wxWindow *arg1 = (wxWindow *) 0 ;
40888 wxPyDropTarget *result = 0 ;
40889 void *argp1 = 0 ;
40890 int res1 = 0 ;
40891 PyObject *swig_obj[1] ;
40892
40893 if (!args) SWIG_fail;
40894 swig_obj[0] = args;
40895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40896 if (!SWIG_IsOK(res1)) {
40897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40898 }
40899 arg1 = reinterpret_cast< wxWindow * >(argp1);
40900 {
40901 PyThreadState* __tstate = wxPyBeginAllowThreads();
40902 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40914 PyObject *resultobj = 0;
40915 wxWindow *arg1 = (wxWindow *) 0 ;
40916 bool arg2 ;
40917 void *argp1 = 0 ;
40918 int res1 = 0 ;
40919 bool val2 ;
40920 int ecode2 = 0 ;
40921 PyObject * obj0 = 0 ;
40922 PyObject * obj1 = 0 ;
40923 char * kwnames[] = {
40924 (char *) "self",(char *) "accept", NULL
40925 };
40926
40927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40929 if (!SWIG_IsOK(res1)) {
40930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40931 }
40932 arg1 = reinterpret_cast< wxWindow * >(argp1);
40933 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40934 if (!SWIG_IsOK(ecode2)) {
40935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40936 }
40937 arg2 = static_cast< bool >(val2);
40938 {
40939 PyThreadState* __tstate = wxPyBeginAllowThreads();
40940 wxWindow_DragAcceptFiles(arg1,arg2);
40941 wxPyEndAllowThreads(__tstate);
40942 if (PyErr_Occurred()) SWIG_fail;
40943 }
40944 resultobj = SWIG_Py_Void();
40945 return resultobj;
40946 fail:
40947 return NULL;
40948 }
40949
40950
40951 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40952 PyObject *resultobj = 0;
40953 wxWindow *arg1 = (wxWindow *) 0 ;
40954 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40955 void *argp1 = 0 ;
40956 int res1 = 0 ;
40957 int res2 = 0 ;
40958 PyObject * obj0 = 0 ;
40959 PyObject * obj1 = 0 ;
40960 char * kwnames[] = {
40961 (char *) "self",(char *) "constraints", NULL
40962 };
40963
40964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40966 if (!SWIG_IsOK(res1)) {
40967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40968 }
40969 arg1 = reinterpret_cast< wxWindow * >(argp1);
40970 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40971 if (!SWIG_IsOK(res2)) {
40972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40973 }
40974 {
40975 PyThreadState* __tstate = wxPyBeginAllowThreads();
40976 (arg1)->SetConstraints(arg2);
40977 wxPyEndAllowThreads(__tstate);
40978 if (PyErr_Occurred()) SWIG_fail;
40979 }
40980 resultobj = SWIG_Py_Void();
40981 return resultobj;
40982 fail:
40983 return NULL;
40984 }
40985
40986
40987 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40988 PyObject *resultobj = 0;
40989 wxWindow *arg1 = (wxWindow *) 0 ;
40990 wxLayoutConstraints *result = 0 ;
40991 void *argp1 = 0 ;
40992 int res1 = 0 ;
40993 PyObject *swig_obj[1] ;
40994
40995 if (!args) SWIG_fail;
40996 swig_obj[0] = args;
40997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40998 if (!SWIG_IsOK(res1)) {
40999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41000 }
41001 arg1 = reinterpret_cast< wxWindow * >(argp1);
41002 {
41003 PyThreadState* __tstate = wxPyBeginAllowThreads();
41004 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41005 wxPyEndAllowThreads(__tstate);
41006 if (PyErr_Occurred()) SWIG_fail;
41007 }
41008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41009 return resultobj;
41010 fail:
41011 return NULL;
41012 }
41013
41014
41015 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41016 PyObject *resultobj = 0;
41017 wxWindow *arg1 = (wxWindow *) 0 ;
41018 bool arg2 ;
41019 void *argp1 = 0 ;
41020 int res1 = 0 ;
41021 bool val2 ;
41022 int ecode2 = 0 ;
41023 PyObject * obj0 = 0 ;
41024 PyObject * obj1 = 0 ;
41025 char * kwnames[] = {
41026 (char *) "self",(char *) "autoLayout", NULL
41027 };
41028
41029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41031 if (!SWIG_IsOK(res1)) {
41032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41033 }
41034 arg1 = reinterpret_cast< wxWindow * >(argp1);
41035 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41036 if (!SWIG_IsOK(ecode2)) {
41037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41038 }
41039 arg2 = static_cast< bool >(val2);
41040 {
41041 PyThreadState* __tstate = wxPyBeginAllowThreads();
41042 (arg1)->SetAutoLayout(arg2);
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 resultobj = SWIG_Py_Void();
41047 return resultobj;
41048 fail:
41049 return NULL;
41050 }
41051
41052
41053 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41054 PyObject *resultobj = 0;
41055 wxWindow *arg1 = (wxWindow *) 0 ;
41056 bool result;
41057 void *argp1 = 0 ;
41058 int res1 = 0 ;
41059 PyObject *swig_obj[1] ;
41060
41061 if (!args) SWIG_fail;
41062 swig_obj[0] = args;
41063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41064 if (!SWIG_IsOK(res1)) {
41065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41066 }
41067 arg1 = reinterpret_cast< wxWindow * >(argp1);
41068 {
41069 PyThreadState* __tstate = wxPyBeginAllowThreads();
41070 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 {
41075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41076 }
41077 return resultobj;
41078 fail:
41079 return NULL;
41080 }
41081
41082
41083 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41084 PyObject *resultobj = 0;
41085 wxWindow *arg1 = (wxWindow *) 0 ;
41086 bool result;
41087 void *argp1 = 0 ;
41088 int res1 = 0 ;
41089 PyObject *swig_obj[1] ;
41090
41091 if (!args) SWIG_fail;
41092 swig_obj[0] = args;
41093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41094 if (!SWIG_IsOK(res1)) {
41095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41096 }
41097 arg1 = reinterpret_cast< wxWindow * >(argp1);
41098 {
41099 PyThreadState* __tstate = wxPyBeginAllowThreads();
41100 result = (bool)(arg1)->Layout();
41101 wxPyEndAllowThreads(__tstate);
41102 if (PyErr_Occurred()) SWIG_fail;
41103 }
41104 {
41105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41106 }
41107 return resultobj;
41108 fail:
41109 return NULL;
41110 }
41111
41112
41113 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41114 PyObject *resultobj = 0;
41115 wxWindow *arg1 = (wxWindow *) 0 ;
41116 wxSizer *arg2 = (wxSizer *) 0 ;
41117 bool arg3 = (bool) true ;
41118 void *argp1 = 0 ;
41119 int res1 = 0 ;
41120 int res2 = 0 ;
41121 bool val3 ;
41122 int ecode3 = 0 ;
41123 PyObject * obj0 = 0 ;
41124 PyObject * obj1 = 0 ;
41125 PyObject * obj2 = 0 ;
41126 char * kwnames[] = {
41127 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41128 };
41129
41130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41132 if (!SWIG_IsOK(res1)) {
41133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41134 }
41135 arg1 = reinterpret_cast< wxWindow * >(argp1);
41136 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41137 if (!SWIG_IsOK(res2)) {
41138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41139 }
41140 if (obj2) {
41141 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41142 if (!SWIG_IsOK(ecode3)) {
41143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41144 }
41145 arg3 = static_cast< bool >(val3);
41146 }
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 (arg1)->SetSizer(arg2,arg3);
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 resultobj = SWIG_Py_Void();
41154 return resultobj;
41155 fail:
41156 return NULL;
41157 }
41158
41159
41160 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41161 PyObject *resultobj = 0;
41162 wxWindow *arg1 = (wxWindow *) 0 ;
41163 wxSizer *arg2 = (wxSizer *) 0 ;
41164 bool arg3 = (bool) true ;
41165 void *argp1 = 0 ;
41166 int res1 = 0 ;
41167 int res2 = 0 ;
41168 bool val3 ;
41169 int ecode3 = 0 ;
41170 PyObject * obj0 = 0 ;
41171 PyObject * obj1 = 0 ;
41172 PyObject * obj2 = 0 ;
41173 char * kwnames[] = {
41174 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41175 };
41176
41177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41179 if (!SWIG_IsOK(res1)) {
41180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41181 }
41182 arg1 = reinterpret_cast< wxWindow * >(argp1);
41183 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41184 if (!SWIG_IsOK(res2)) {
41185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41186 }
41187 if (obj2) {
41188 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41189 if (!SWIG_IsOK(ecode3)) {
41190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41191 }
41192 arg3 = static_cast< bool >(val3);
41193 }
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 (arg1)->SetSizerAndFit(arg2,arg3);
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 resultobj = SWIG_Py_Void();
41201 return resultobj;
41202 fail:
41203 return NULL;
41204 }
41205
41206
41207 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41208 PyObject *resultobj = 0;
41209 wxWindow *arg1 = (wxWindow *) 0 ;
41210 wxSizer *result = 0 ;
41211 void *argp1 = 0 ;
41212 int res1 = 0 ;
41213 PyObject *swig_obj[1] ;
41214
41215 if (!args) SWIG_fail;
41216 swig_obj[0] = args;
41217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41218 if (!SWIG_IsOK(res1)) {
41219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41220 }
41221 arg1 = reinterpret_cast< wxWindow * >(argp1);
41222 {
41223 PyThreadState* __tstate = wxPyBeginAllowThreads();
41224 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41225 wxPyEndAllowThreads(__tstate);
41226 if (PyErr_Occurred()) SWIG_fail;
41227 }
41228 {
41229 resultobj = wxPyMake_wxObject(result, (bool)0);
41230 }
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41238 PyObject *resultobj = 0;
41239 wxWindow *arg1 = (wxWindow *) 0 ;
41240 wxSizer *arg2 = (wxSizer *) 0 ;
41241 void *argp1 = 0 ;
41242 int res1 = 0 ;
41243 void *argp2 = 0 ;
41244 int res2 = 0 ;
41245 PyObject * obj0 = 0 ;
41246 PyObject * obj1 = 0 ;
41247 char * kwnames[] = {
41248 (char *) "self",(char *) "sizer", NULL
41249 };
41250
41251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41253 if (!SWIG_IsOK(res1)) {
41254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41255 }
41256 arg1 = reinterpret_cast< wxWindow * >(argp1);
41257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41258 if (!SWIG_IsOK(res2)) {
41259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41260 }
41261 arg2 = reinterpret_cast< wxSizer * >(argp2);
41262 {
41263 PyThreadState* __tstate = wxPyBeginAllowThreads();
41264 (arg1)->SetContainingSizer(arg2);
41265 wxPyEndAllowThreads(__tstate);
41266 if (PyErr_Occurred()) SWIG_fail;
41267 }
41268 resultobj = SWIG_Py_Void();
41269 return resultobj;
41270 fail:
41271 return NULL;
41272 }
41273
41274
41275 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41276 PyObject *resultobj = 0;
41277 wxWindow *arg1 = (wxWindow *) 0 ;
41278 wxSizer *result = 0 ;
41279 void *argp1 = 0 ;
41280 int res1 = 0 ;
41281 PyObject *swig_obj[1] ;
41282
41283 if (!args) SWIG_fail;
41284 swig_obj[0] = args;
41285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41286 if (!SWIG_IsOK(res1)) {
41287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41288 }
41289 arg1 = reinterpret_cast< wxWindow * >(argp1);
41290 {
41291 PyThreadState* __tstate = wxPyBeginAllowThreads();
41292 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41293 wxPyEndAllowThreads(__tstate);
41294 if (PyErr_Occurred()) SWIG_fail;
41295 }
41296 {
41297 resultobj = wxPyMake_wxObject(result, (bool)0);
41298 }
41299 return resultobj;
41300 fail:
41301 return NULL;
41302 }
41303
41304
41305 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41306 PyObject *resultobj = 0;
41307 wxWindow *arg1 = (wxWindow *) 0 ;
41308 void *argp1 = 0 ;
41309 int res1 = 0 ;
41310 PyObject *swig_obj[1] ;
41311
41312 if (!args) SWIG_fail;
41313 swig_obj[0] = args;
41314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41315 if (!SWIG_IsOK(res1)) {
41316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41317 }
41318 arg1 = reinterpret_cast< wxWindow * >(argp1);
41319 {
41320 PyThreadState* __tstate = wxPyBeginAllowThreads();
41321 (arg1)->InheritAttributes();
41322 wxPyEndAllowThreads(__tstate);
41323 if (PyErr_Occurred()) SWIG_fail;
41324 }
41325 resultobj = SWIG_Py_Void();
41326 return resultobj;
41327 fail:
41328 return NULL;
41329 }
41330
41331
41332 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41333 PyObject *resultobj = 0;
41334 wxWindow *arg1 = (wxWindow *) 0 ;
41335 bool result;
41336 void *argp1 = 0 ;
41337 int res1 = 0 ;
41338 PyObject *swig_obj[1] ;
41339
41340 if (!args) SWIG_fail;
41341 swig_obj[0] = args;
41342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41343 if (!SWIG_IsOK(res1)) {
41344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41345 }
41346 arg1 = reinterpret_cast< wxWindow * >(argp1);
41347 {
41348 PyThreadState* __tstate = wxPyBeginAllowThreads();
41349 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41350 wxPyEndAllowThreads(__tstate);
41351 if (PyErr_Occurred()) SWIG_fail;
41352 }
41353 {
41354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41355 }
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41363 PyObject *resultobj = 0;
41364 wxWindow *arg1 = (wxWindow *) 0 ;
41365 bool result;
41366 void *argp1 = 0 ;
41367 int res1 = 0 ;
41368 PyObject *swig_obj[1] ;
41369
41370 if (!args) SWIG_fail;
41371 swig_obj[0] = args;
41372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41373 if (!SWIG_IsOK(res1)) {
41374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41375 }
41376 arg1 = reinterpret_cast< wxWindow * >(argp1);
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 result = (bool)(arg1)->CanSetTransparent();
41380 wxPyEndAllowThreads(__tstate);
41381 if (PyErr_Occurred()) SWIG_fail;
41382 }
41383 {
41384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41385 }
41386 return resultobj;
41387 fail:
41388 return NULL;
41389 }
41390
41391
41392 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj = 0;
41394 wxWindow *arg1 = (wxWindow *) 0 ;
41395 byte arg2 ;
41396 bool result;
41397 void *argp1 = 0 ;
41398 int res1 = 0 ;
41399 unsigned char val2 ;
41400 int ecode2 = 0 ;
41401 PyObject * obj0 = 0 ;
41402 PyObject * obj1 = 0 ;
41403 char * kwnames[] = {
41404 (char *) "self",(char *) "alpha", NULL
41405 };
41406
41407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41409 if (!SWIG_IsOK(res1)) {
41410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41411 }
41412 arg1 = reinterpret_cast< wxWindow * >(argp1);
41413 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41414 if (!SWIG_IsOK(ecode2)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41416 }
41417 arg2 = static_cast< byte >(val2);
41418 {
41419 PyThreadState* __tstate = wxPyBeginAllowThreads();
41420 result = (bool)(arg1)->SetTransparent(arg2);
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 {
41425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41426 }
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41434 PyObject *obj;
41435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41436 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41437 return SWIG_Py_Void();
41438 }
41439
41440 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41441 return SWIG_Python_InitShadowInstance(args);
41442 }
41443
41444 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj = 0;
41446 long arg1 ;
41447 wxWindow *arg2 = (wxWindow *) NULL ;
41448 wxWindow *result = 0 ;
41449 long val1 ;
41450 int ecode1 = 0 ;
41451 void *argp2 = 0 ;
41452 int res2 = 0 ;
41453 PyObject * obj0 = 0 ;
41454 PyObject * obj1 = 0 ;
41455 char * kwnames[] = {
41456 (char *) "id",(char *) "parent", NULL
41457 };
41458
41459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41460 ecode1 = SWIG_AsVal_long(obj0, &val1);
41461 if (!SWIG_IsOK(ecode1)) {
41462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41463 }
41464 arg1 = static_cast< long >(val1);
41465 if (obj1) {
41466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41467 if (!SWIG_IsOK(res2)) {
41468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41469 }
41470 arg2 = reinterpret_cast< wxWindow * >(argp2);
41471 }
41472 {
41473 if (!wxPyCheckForApp()) SWIG_fail;
41474 PyThreadState* __tstate = wxPyBeginAllowThreads();
41475 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41476 wxPyEndAllowThreads(__tstate);
41477 if (PyErr_Occurred()) SWIG_fail;
41478 }
41479 {
41480 resultobj = wxPyMake_wxObject(result, 0);
41481 }
41482 return resultobj;
41483 fail:
41484 return NULL;
41485 }
41486
41487
41488 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41489 PyObject *resultobj = 0;
41490 wxString *arg1 = 0 ;
41491 wxWindow *arg2 = (wxWindow *) NULL ;
41492 wxWindow *result = 0 ;
41493 bool temp1 = false ;
41494 void *argp2 = 0 ;
41495 int res2 = 0 ;
41496 PyObject * obj0 = 0 ;
41497 PyObject * obj1 = 0 ;
41498 char * kwnames[] = {
41499 (char *) "name",(char *) "parent", NULL
41500 };
41501
41502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41503 {
41504 arg1 = wxString_in_helper(obj0);
41505 if (arg1 == NULL) SWIG_fail;
41506 temp1 = true;
41507 }
41508 if (obj1) {
41509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41510 if (!SWIG_IsOK(res2)) {
41511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41512 }
41513 arg2 = reinterpret_cast< wxWindow * >(argp2);
41514 }
41515 {
41516 if (!wxPyCheckForApp()) SWIG_fail;
41517 PyThreadState* __tstate = wxPyBeginAllowThreads();
41518 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41519 wxPyEndAllowThreads(__tstate);
41520 if (PyErr_Occurred()) SWIG_fail;
41521 }
41522 {
41523 resultobj = wxPyMake_wxObject(result, 0);
41524 }
41525 {
41526 if (temp1)
41527 delete arg1;
41528 }
41529 return resultobj;
41530 fail:
41531 {
41532 if (temp1)
41533 delete arg1;
41534 }
41535 return NULL;
41536 }
41537
41538
41539 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41540 PyObject *resultobj = 0;
41541 wxString *arg1 = 0 ;
41542 wxWindow *arg2 = (wxWindow *) NULL ;
41543 wxWindow *result = 0 ;
41544 bool temp1 = false ;
41545 void *argp2 = 0 ;
41546 int res2 = 0 ;
41547 PyObject * obj0 = 0 ;
41548 PyObject * obj1 = 0 ;
41549 char * kwnames[] = {
41550 (char *) "label",(char *) "parent", NULL
41551 };
41552
41553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41554 {
41555 arg1 = wxString_in_helper(obj0);
41556 if (arg1 == NULL) SWIG_fail;
41557 temp1 = true;
41558 }
41559 if (obj1) {
41560 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41561 if (!SWIG_IsOK(res2)) {
41562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41563 }
41564 arg2 = reinterpret_cast< wxWindow * >(argp2);
41565 }
41566 {
41567 if (!wxPyCheckForApp()) SWIG_fail;
41568 PyThreadState* __tstate = wxPyBeginAllowThreads();
41569 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 {
41574 resultobj = wxPyMake_wxObject(result, 0);
41575 }
41576 {
41577 if (temp1)
41578 delete arg1;
41579 }
41580 return resultobj;
41581 fail:
41582 {
41583 if (temp1)
41584 delete arg1;
41585 }
41586 return NULL;
41587 }
41588
41589
41590 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41591 PyObject *resultobj = 0;
41592 wxWindow *arg1 = (wxWindow *) 0 ;
41593 unsigned long arg2 ;
41594 wxWindow *result = 0 ;
41595 void *argp1 = 0 ;
41596 int res1 = 0 ;
41597 unsigned long val2 ;
41598 int ecode2 = 0 ;
41599 PyObject * obj0 = 0 ;
41600 PyObject * obj1 = 0 ;
41601 char * kwnames[] = {
41602 (char *) "parent",(char *) "_hWnd", NULL
41603 };
41604
41605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41607 if (!SWIG_IsOK(res1)) {
41608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41609 }
41610 arg1 = reinterpret_cast< wxWindow * >(argp1);
41611 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41612 if (!SWIG_IsOK(ecode2)) {
41613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41614 }
41615 arg2 = static_cast< unsigned long >(val2);
41616 {
41617 if (!wxPyCheckForApp()) SWIG_fail;
41618 PyThreadState* __tstate = wxPyBeginAllowThreads();
41619 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41620 wxPyEndAllowThreads(__tstate);
41621 if (PyErr_Occurred()) SWIG_fail;
41622 }
41623 {
41624 resultobj = wxPyMake_wxObject(result, 0);
41625 }
41626 return resultobj;
41627 fail:
41628 return NULL;
41629 }
41630
41631
41632 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41633 PyObject *resultobj = 0;
41634 PyObject *result = 0 ;
41635
41636 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41637 {
41638 PyThreadState* __tstate = wxPyBeginAllowThreads();
41639 result = (PyObject *)GetTopLevelWindows();
41640 wxPyEndAllowThreads(__tstate);
41641 if (PyErr_Occurred()) SWIG_fail;
41642 }
41643 resultobj = result;
41644 return resultobj;
41645 fail:
41646 return NULL;
41647 }
41648
41649
41650 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41651 PyObject *resultobj = 0;
41652 wxValidator *result = 0 ;
41653
41654 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41655 {
41656 PyThreadState* __tstate = wxPyBeginAllowThreads();
41657 result = (wxValidator *)new wxValidator();
41658 wxPyEndAllowThreads(__tstate);
41659 if (PyErr_Occurred()) SWIG_fail;
41660 }
41661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41662 return resultobj;
41663 fail:
41664 return NULL;
41665 }
41666
41667
41668 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41669 PyObject *resultobj = 0;
41670 wxValidator *arg1 = (wxValidator *) 0 ;
41671 wxValidator *result = 0 ;
41672 void *argp1 = 0 ;
41673 int res1 = 0 ;
41674 PyObject *swig_obj[1] ;
41675
41676 if (!args) SWIG_fail;
41677 swig_obj[0] = args;
41678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41679 if (!SWIG_IsOK(res1)) {
41680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41681 }
41682 arg1 = reinterpret_cast< wxValidator * >(argp1);
41683 {
41684 PyThreadState* __tstate = wxPyBeginAllowThreads();
41685 result = (wxValidator *)(arg1)->Clone();
41686 wxPyEndAllowThreads(__tstate);
41687 if (PyErr_Occurred()) SWIG_fail;
41688 }
41689 {
41690 resultobj = wxPyMake_wxObject(result, 0);
41691 }
41692 return resultobj;
41693 fail:
41694 return NULL;
41695 }
41696
41697
41698 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41699 PyObject *resultobj = 0;
41700 wxValidator *arg1 = (wxValidator *) 0 ;
41701 wxWindow *arg2 = (wxWindow *) 0 ;
41702 bool result;
41703 void *argp1 = 0 ;
41704 int res1 = 0 ;
41705 void *argp2 = 0 ;
41706 int res2 = 0 ;
41707 PyObject * obj0 = 0 ;
41708 PyObject * obj1 = 0 ;
41709 char * kwnames[] = {
41710 (char *) "self",(char *) "parent", NULL
41711 };
41712
41713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41715 if (!SWIG_IsOK(res1)) {
41716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41717 }
41718 arg1 = reinterpret_cast< wxValidator * >(argp1);
41719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41720 if (!SWIG_IsOK(res2)) {
41721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41722 }
41723 arg2 = reinterpret_cast< wxWindow * >(argp2);
41724 {
41725 PyThreadState* __tstate = wxPyBeginAllowThreads();
41726 result = (bool)(arg1)->Validate(arg2);
41727 wxPyEndAllowThreads(__tstate);
41728 if (PyErr_Occurred()) SWIG_fail;
41729 }
41730 {
41731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41732 }
41733 return resultobj;
41734 fail:
41735 return NULL;
41736 }
41737
41738
41739 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41740 PyObject *resultobj = 0;
41741 wxValidator *arg1 = (wxValidator *) 0 ;
41742 bool result;
41743 void *argp1 = 0 ;
41744 int res1 = 0 ;
41745 PyObject *swig_obj[1] ;
41746
41747 if (!args) SWIG_fail;
41748 swig_obj[0] = args;
41749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41750 if (!SWIG_IsOK(res1)) {
41751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41752 }
41753 arg1 = reinterpret_cast< wxValidator * >(argp1);
41754 {
41755 PyThreadState* __tstate = wxPyBeginAllowThreads();
41756 result = (bool)(arg1)->TransferToWindow();
41757 wxPyEndAllowThreads(__tstate);
41758 if (PyErr_Occurred()) SWIG_fail;
41759 }
41760 {
41761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41762 }
41763 return resultobj;
41764 fail:
41765 return NULL;
41766 }
41767
41768
41769 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41770 PyObject *resultobj = 0;
41771 wxValidator *arg1 = (wxValidator *) 0 ;
41772 bool result;
41773 void *argp1 = 0 ;
41774 int res1 = 0 ;
41775 PyObject *swig_obj[1] ;
41776
41777 if (!args) SWIG_fail;
41778 swig_obj[0] = args;
41779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41780 if (!SWIG_IsOK(res1)) {
41781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41782 }
41783 arg1 = reinterpret_cast< wxValidator * >(argp1);
41784 {
41785 PyThreadState* __tstate = wxPyBeginAllowThreads();
41786 result = (bool)(arg1)->TransferFromWindow();
41787 wxPyEndAllowThreads(__tstate);
41788 if (PyErr_Occurred()) SWIG_fail;
41789 }
41790 {
41791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41792 }
41793 return resultobj;
41794 fail:
41795 return NULL;
41796 }
41797
41798
41799 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41800 PyObject *resultobj = 0;
41801 wxValidator *arg1 = (wxValidator *) 0 ;
41802 wxWindow *result = 0 ;
41803 void *argp1 = 0 ;
41804 int res1 = 0 ;
41805 PyObject *swig_obj[1] ;
41806
41807 if (!args) SWIG_fail;
41808 swig_obj[0] = args;
41809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41810 if (!SWIG_IsOK(res1)) {
41811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41812 }
41813 arg1 = reinterpret_cast< wxValidator * >(argp1);
41814 {
41815 PyThreadState* __tstate = wxPyBeginAllowThreads();
41816 result = (wxWindow *)(arg1)->GetWindow();
41817 wxPyEndAllowThreads(__tstate);
41818 if (PyErr_Occurred()) SWIG_fail;
41819 }
41820 {
41821 resultobj = wxPyMake_wxObject(result, 0);
41822 }
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41830 PyObject *resultobj = 0;
41831 wxValidator *arg1 = (wxValidator *) 0 ;
41832 wxWindow *arg2 = (wxWindow *) 0 ;
41833 void *argp1 = 0 ;
41834 int res1 = 0 ;
41835 void *argp2 = 0 ;
41836 int res2 = 0 ;
41837 PyObject * obj0 = 0 ;
41838 PyObject * obj1 = 0 ;
41839 char * kwnames[] = {
41840 (char *) "self",(char *) "window", NULL
41841 };
41842
41843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41845 if (!SWIG_IsOK(res1)) {
41846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41847 }
41848 arg1 = reinterpret_cast< wxValidator * >(argp1);
41849 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41850 if (!SWIG_IsOK(res2)) {
41851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41852 }
41853 arg2 = reinterpret_cast< wxWindow * >(argp2);
41854 {
41855 PyThreadState* __tstate = wxPyBeginAllowThreads();
41856 (arg1)->SetWindow(arg2);
41857 wxPyEndAllowThreads(__tstate);
41858 if (PyErr_Occurred()) SWIG_fail;
41859 }
41860 resultobj = SWIG_Py_Void();
41861 return resultobj;
41862 fail:
41863 return NULL;
41864 }
41865
41866
41867 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41868 PyObject *resultobj = 0;
41869 bool result;
41870
41871 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41872 {
41873 PyThreadState* __tstate = wxPyBeginAllowThreads();
41874 result = (bool)wxValidator::IsSilent();
41875 wxPyEndAllowThreads(__tstate);
41876 if (PyErr_Occurred()) SWIG_fail;
41877 }
41878 {
41879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41880 }
41881 return resultobj;
41882 fail:
41883 return NULL;
41884 }
41885
41886
41887 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41888 PyObject *resultobj = 0;
41889 int arg1 = (int) true ;
41890 int val1 ;
41891 int ecode1 = 0 ;
41892 PyObject * obj0 = 0 ;
41893 char * kwnames[] = {
41894 (char *) "doIt", NULL
41895 };
41896
41897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41898 if (obj0) {
41899 ecode1 = SWIG_AsVal_int(obj0, &val1);
41900 if (!SWIG_IsOK(ecode1)) {
41901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41902 }
41903 arg1 = static_cast< int >(val1);
41904 }
41905 {
41906 PyThreadState* __tstate = wxPyBeginAllowThreads();
41907 wxValidator::SetBellOnError(arg1);
41908 wxPyEndAllowThreads(__tstate);
41909 if (PyErr_Occurred()) SWIG_fail;
41910 }
41911 resultobj = SWIG_Py_Void();
41912 return resultobj;
41913 fail:
41914 return NULL;
41915 }
41916
41917
41918 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41919 PyObject *obj;
41920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41921 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41922 return SWIG_Py_Void();
41923 }
41924
41925 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41926 return SWIG_Python_InitShadowInstance(args);
41927 }
41928
41929 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41930 PyObject *resultobj = 0;
41931 wxPyValidator *result = 0 ;
41932
41933 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41934 {
41935 PyThreadState* __tstate = wxPyBeginAllowThreads();
41936 result = (wxPyValidator *)new wxPyValidator();
41937 wxPyEndAllowThreads(__tstate);
41938 if (PyErr_Occurred()) SWIG_fail;
41939 }
41940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41941 return resultobj;
41942 fail:
41943 return NULL;
41944 }
41945
41946
41947 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41948 PyObject *resultobj = 0;
41949 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41950 PyObject *arg2 = (PyObject *) 0 ;
41951 PyObject *arg3 = (PyObject *) 0 ;
41952 int arg4 = (int) 1 ;
41953 void *argp1 = 0 ;
41954 int res1 = 0 ;
41955 int val4 ;
41956 int ecode4 = 0 ;
41957 PyObject * obj0 = 0 ;
41958 PyObject * obj1 = 0 ;
41959 PyObject * obj2 = 0 ;
41960 PyObject * obj3 = 0 ;
41961 char * kwnames[] = {
41962 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41963 };
41964
41965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41967 if (!SWIG_IsOK(res1)) {
41968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41969 }
41970 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41971 arg2 = obj1;
41972 arg3 = obj2;
41973 if (obj3) {
41974 ecode4 = SWIG_AsVal_int(obj3, &val4);
41975 if (!SWIG_IsOK(ecode4)) {
41976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41977 }
41978 arg4 = static_cast< int >(val4);
41979 }
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41983 wxPyEndAllowThreads(__tstate);
41984 if (PyErr_Occurred()) SWIG_fail;
41985 }
41986 resultobj = SWIG_Py_Void();
41987 return resultobj;
41988 fail:
41989 return NULL;
41990 }
41991
41992
41993 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41994 PyObject *obj;
41995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41996 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41997 return SWIG_Py_Void();
41998 }
41999
42000 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42001 return SWIG_Python_InitShadowInstance(args);
42002 }
42003
42004 SWIGINTERN int DefaultValidator_set(PyObject *) {
42005 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42006 return 1;
42007 }
42008
42009
42010 SWIGINTERN PyObject *DefaultValidator_get(void) {
42011 PyObject *pyobj = 0;
42012
42013 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42014 return pyobj;
42015 }
42016
42017
42018 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42019 PyObject *resultobj = 0;
42020 wxString const &arg1_defvalue = wxPyEmptyString ;
42021 wxString *arg1 = (wxString *) &arg1_defvalue ;
42022 long arg2 = (long) 0 ;
42023 wxMenu *result = 0 ;
42024 bool temp1 = false ;
42025 long val2 ;
42026 int ecode2 = 0 ;
42027 PyObject * obj0 = 0 ;
42028 PyObject * obj1 = 0 ;
42029 char * kwnames[] = {
42030 (char *) "title",(char *) "style", NULL
42031 };
42032
42033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42034 if (obj0) {
42035 {
42036 arg1 = wxString_in_helper(obj0);
42037 if (arg1 == NULL) SWIG_fail;
42038 temp1 = true;
42039 }
42040 }
42041 if (obj1) {
42042 ecode2 = SWIG_AsVal_long(obj1, &val2);
42043 if (!SWIG_IsOK(ecode2)) {
42044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42045 }
42046 arg2 = static_cast< long >(val2);
42047 }
42048 {
42049 if (!wxPyCheckForApp()) SWIG_fail;
42050 PyThreadState* __tstate = wxPyBeginAllowThreads();
42051 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42052 wxPyEndAllowThreads(__tstate);
42053 if (PyErr_Occurred()) SWIG_fail;
42054 }
42055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42056 {
42057 if (temp1)
42058 delete arg1;
42059 }
42060 return resultobj;
42061 fail:
42062 {
42063 if (temp1)
42064 delete arg1;
42065 }
42066 return NULL;
42067 }
42068
42069
42070 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42071 PyObject *resultobj = 0;
42072 wxMenu *arg1 = (wxMenu *) 0 ;
42073 int arg2 ;
42074 wxString const &arg3_defvalue = wxPyEmptyString ;
42075 wxString *arg3 = (wxString *) &arg3_defvalue ;
42076 wxString const &arg4_defvalue = wxPyEmptyString ;
42077 wxString *arg4 = (wxString *) &arg4_defvalue ;
42078 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42079 wxMenuItem *result = 0 ;
42080 void *argp1 = 0 ;
42081 int res1 = 0 ;
42082 int val2 ;
42083 int ecode2 = 0 ;
42084 bool temp3 = false ;
42085 bool temp4 = false ;
42086 int val5 ;
42087 int ecode5 = 0 ;
42088 PyObject * obj0 = 0 ;
42089 PyObject * obj1 = 0 ;
42090 PyObject * obj2 = 0 ;
42091 PyObject * obj3 = 0 ;
42092 PyObject * obj4 = 0 ;
42093 char * kwnames[] = {
42094 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42095 };
42096
42097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42099 if (!SWIG_IsOK(res1)) {
42100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42101 }
42102 arg1 = reinterpret_cast< wxMenu * >(argp1);
42103 ecode2 = SWIG_AsVal_int(obj1, &val2);
42104 if (!SWIG_IsOK(ecode2)) {
42105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42106 }
42107 arg2 = static_cast< int >(val2);
42108 if (obj2) {
42109 {
42110 arg3 = wxString_in_helper(obj2);
42111 if (arg3 == NULL) SWIG_fail;
42112 temp3 = true;
42113 }
42114 }
42115 if (obj3) {
42116 {
42117 arg4 = wxString_in_helper(obj3);
42118 if (arg4 == NULL) SWIG_fail;
42119 temp4 = true;
42120 }
42121 }
42122 if (obj4) {
42123 ecode5 = SWIG_AsVal_int(obj4, &val5);
42124 if (!SWIG_IsOK(ecode5)) {
42125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42126 }
42127 arg5 = static_cast< wxItemKind >(val5);
42128 }
42129 {
42130 PyThreadState* __tstate = wxPyBeginAllowThreads();
42131 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42132 wxPyEndAllowThreads(__tstate);
42133 if (PyErr_Occurred()) SWIG_fail;
42134 }
42135 {
42136 resultobj = wxPyMake_wxObject(result, (bool)0);
42137 }
42138 {
42139 if (temp3)
42140 delete arg3;
42141 }
42142 {
42143 if (temp4)
42144 delete arg4;
42145 }
42146 return resultobj;
42147 fail:
42148 {
42149 if (temp3)
42150 delete arg3;
42151 }
42152 {
42153 if (temp4)
42154 delete arg4;
42155 }
42156 return NULL;
42157 }
42158
42159
42160 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42161 PyObject *resultobj = 0;
42162 wxMenu *arg1 = (wxMenu *) 0 ;
42163 wxMenuItem *result = 0 ;
42164 void *argp1 = 0 ;
42165 int res1 = 0 ;
42166 PyObject *swig_obj[1] ;
42167
42168 if (!args) SWIG_fail;
42169 swig_obj[0] = args;
42170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42171 if (!SWIG_IsOK(res1)) {
42172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42173 }
42174 arg1 = reinterpret_cast< wxMenu * >(argp1);
42175 {
42176 PyThreadState* __tstate = wxPyBeginAllowThreads();
42177 result = (wxMenuItem *)(arg1)->AppendSeparator();
42178 wxPyEndAllowThreads(__tstate);
42179 if (PyErr_Occurred()) SWIG_fail;
42180 }
42181 {
42182 resultobj = wxPyMake_wxObject(result, (bool)0);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42191 PyObject *resultobj = 0;
42192 wxMenu *arg1 = (wxMenu *) 0 ;
42193 int arg2 ;
42194 wxString *arg3 = 0 ;
42195 wxString const &arg4_defvalue = wxPyEmptyString ;
42196 wxString *arg4 = (wxString *) &arg4_defvalue ;
42197 wxMenuItem *result = 0 ;
42198 void *argp1 = 0 ;
42199 int res1 = 0 ;
42200 int val2 ;
42201 int ecode2 = 0 ;
42202 bool temp3 = false ;
42203 bool temp4 = false ;
42204 PyObject * obj0 = 0 ;
42205 PyObject * obj1 = 0 ;
42206 PyObject * obj2 = 0 ;
42207 PyObject * obj3 = 0 ;
42208 char * kwnames[] = {
42209 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42210 };
42211
42212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42214 if (!SWIG_IsOK(res1)) {
42215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42216 }
42217 arg1 = reinterpret_cast< wxMenu * >(argp1);
42218 ecode2 = SWIG_AsVal_int(obj1, &val2);
42219 if (!SWIG_IsOK(ecode2)) {
42220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42221 }
42222 arg2 = static_cast< int >(val2);
42223 {
42224 arg3 = wxString_in_helper(obj2);
42225 if (arg3 == NULL) SWIG_fail;
42226 temp3 = true;
42227 }
42228 if (obj3) {
42229 {
42230 arg4 = wxString_in_helper(obj3);
42231 if (arg4 == NULL) SWIG_fail;
42232 temp4 = true;
42233 }
42234 }
42235 {
42236 PyThreadState* __tstate = wxPyBeginAllowThreads();
42237 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42238 wxPyEndAllowThreads(__tstate);
42239 if (PyErr_Occurred()) SWIG_fail;
42240 }
42241 {
42242 resultobj = wxPyMake_wxObject(result, (bool)0);
42243 }
42244 {
42245 if (temp3)
42246 delete arg3;
42247 }
42248 {
42249 if (temp4)
42250 delete arg4;
42251 }
42252 return resultobj;
42253 fail:
42254 {
42255 if (temp3)
42256 delete arg3;
42257 }
42258 {
42259 if (temp4)
42260 delete arg4;
42261 }
42262 return NULL;
42263 }
42264
42265
42266 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42267 PyObject *resultobj = 0;
42268 wxMenu *arg1 = (wxMenu *) 0 ;
42269 int arg2 ;
42270 wxString *arg3 = 0 ;
42271 wxString const &arg4_defvalue = wxPyEmptyString ;
42272 wxString *arg4 = (wxString *) &arg4_defvalue ;
42273 wxMenuItem *result = 0 ;
42274 void *argp1 = 0 ;
42275 int res1 = 0 ;
42276 int val2 ;
42277 int ecode2 = 0 ;
42278 bool temp3 = false ;
42279 bool temp4 = false ;
42280 PyObject * obj0 = 0 ;
42281 PyObject * obj1 = 0 ;
42282 PyObject * obj2 = 0 ;
42283 PyObject * obj3 = 0 ;
42284 char * kwnames[] = {
42285 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42286 };
42287
42288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42290 if (!SWIG_IsOK(res1)) {
42291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42292 }
42293 arg1 = reinterpret_cast< wxMenu * >(argp1);
42294 ecode2 = SWIG_AsVal_int(obj1, &val2);
42295 if (!SWIG_IsOK(ecode2)) {
42296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42297 }
42298 arg2 = static_cast< int >(val2);
42299 {
42300 arg3 = wxString_in_helper(obj2);
42301 if (arg3 == NULL) SWIG_fail;
42302 temp3 = true;
42303 }
42304 if (obj3) {
42305 {
42306 arg4 = wxString_in_helper(obj3);
42307 if (arg4 == NULL) SWIG_fail;
42308 temp4 = true;
42309 }
42310 }
42311 {
42312 PyThreadState* __tstate = wxPyBeginAllowThreads();
42313 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42314 wxPyEndAllowThreads(__tstate);
42315 if (PyErr_Occurred()) SWIG_fail;
42316 }
42317 {
42318 resultobj = wxPyMake_wxObject(result, (bool)0);
42319 }
42320 {
42321 if (temp3)
42322 delete arg3;
42323 }
42324 {
42325 if (temp4)
42326 delete arg4;
42327 }
42328 return resultobj;
42329 fail:
42330 {
42331 if (temp3)
42332 delete arg3;
42333 }
42334 {
42335 if (temp4)
42336 delete arg4;
42337 }
42338 return NULL;
42339 }
42340
42341
42342 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42343 PyObject *resultobj = 0;
42344 wxMenu *arg1 = (wxMenu *) 0 ;
42345 int arg2 ;
42346 wxString *arg3 = 0 ;
42347 wxMenu *arg4 = (wxMenu *) 0 ;
42348 wxString const &arg5_defvalue = wxPyEmptyString ;
42349 wxString *arg5 = (wxString *) &arg5_defvalue ;
42350 wxMenuItem *result = 0 ;
42351 void *argp1 = 0 ;
42352 int res1 = 0 ;
42353 int val2 ;
42354 int ecode2 = 0 ;
42355 bool temp3 = false ;
42356 void *argp4 = 0 ;
42357 int res4 = 0 ;
42358 bool temp5 = false ;
42359 PyObject * obj0 = 0 ;
42360 PyObject * obj1 = 0 ;
42361 PyObject * obj2 = 0 ;
42362 PyObject * obj3 = 0 ;
42363 PyObject * obj4 = 0 ;
42364 char * kwnames[] = {
42365 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42366 };
42367
42368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42370 if (!SWIG_IsOK(res1)) {
42371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42372 }
42373 arg1 = reinterpret_cast< wxMenu * >(argp1);
42374 ecode2 = SWIG_AsVal_int(obj1, &val2);
42375 if (!SWIG_IsOK(ecode2)) {
42376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42377 }
42378 arg2 = static_cast< int >(val2);
42379 {
42380 arg3 = wxString_in_helper(obj2);
42381 if (arg3 == NULL) SWIG_fail;
42382 temp3 = true;
42383 }
42384 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42385 if (!SWIG_IsOK(res4)) {
42386 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42387 }
42388 arg4 = reinterpret_cast< wxMenu * >(argp4);
42389 if (obj4) {
42390 {
42391 arg5 = wxString_in_helper(obj4);
42392 if (arg5 == NULL) SWIG_fail;
42393 temp5 = true;
42394 }
42395 }
42396 {
42397 PyThreadState* __tstate = wxPyBeginAllowThreads();
42398 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42399 wxPyEndAllowThreads(__tstate);
42400 if (PyErr_Occurred()) SWIG_fail;
42401 }
42402 {
42403 resultobj = wxPyMake_wxObject(result, (bool)0);
42404 }
42405 {
42406 if (temp3)
42407 delete arg3;
42408 }
42409 {
42410 if (temp5)
42411 delete arg5;
42412 }
42413 return resultobj;
42414 fail:
42415 {
42416 if (temp3)
42417 delete arg3;
42418 }
42419 {
42420 if (temp5)
42421 delete arg5;
42422 }
42423 return NULL;
42424 }
42425
42426
42427 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj = 0;
42429 wxMenu *arg1 = (wxMenu *) 0 ;
42430 wxMenu *arg2 = (wxMenu *) 0 ;
42431 wxString *arg3 = 0 ;
42432 wxString const &arg4_defvalue = wxPyEmptyString ;
42433 wxString *arg4 = (wxString *) &arg4_defvalue ;
42434 wxMenuItem *result = 0 ;
42435 void *argp1 = 0 ;
42436 int res1 = 0 ;
42437 void *argp2 = 0 ;
42438 int res2 = 0 ;
42439 bool temp3 = false ;
42440 bool temp4 = false ;
42441 PyObject * obj0 = 0 ;
42442 PyObject * obj1 = 0 ;
42443 PyObject * obj2 = 0 ;
42444 PyObject * obj3 = 0 ;
42445 char * kwnames[] = {
42446 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42447 };
42448
42449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42451 if (!SWIG_IsOK(res1)) {
42452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42453 }
42454 arg1 = reinterpret_cast< wxMenu * >(argp1);
42455 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42456 if (!SWIG_IsOK(res2)) {
42457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42458 }
42459 arg2 = reinterpret_cast< wxMenu * >(argp2);
42460 {
42461 arg3 = wxString_in_helper(obj2);
42462 if (arg3 == NULL) SWIG_fail;
42463 temp3 = true;
42464 }
42465 if (obj3) {
42466 {
42467 arg4 = wxString_in_helper(obj3);
42468 if (arg4 == NULL) SWIG_fail;
42469 temp4 = true;
42470 }
42471 }
42472 {
42473 PyThreadState* __tstate = wxPyBeginAllowThreads();
42474 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42475 wxPyEndAllowThreads(__tstate);
42476 if (PyErr_Occurred()) SWIG_fail;
42477 }
42478 {
42479 resultobj = wxPyMake_wxObject(result, (bool)0);
42480 }
42481 {
42482 if (temp3)
42483 delete arg3;
42484 }
42485 {
42486 if (temp4)
42487 delete arg4;
42488 }
42489 return resultobj;
42490 fail:
42491 {
42492 if (temp3)
42493 delete arg3;
42494 }
42495 {
42496 if (temp4)
42497 delete arg4;
42498 }
42499 return NULL;
42500 }
42501
42502
42503 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42504 PyObject *resultobj = 0;
42505 wxMenu *arg1 = (wxMenu *) 0 ;
42506 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42507 wxMenuItem *result = 0 ;
42508 void *argp1 = 0 ;
42509 int res1 = 0 ;
42510 int res2 = 0 ;
42511 PyObject * obj0 = 0 ;
42512 PyObject * obj1 = 0 ;
42513 char * kwnames[] = {
42514 (char *) "self",(char *) "item", NULL
42515 };
42516
42517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42519 if (!SWIG_IsOK(res1)) {
42520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42521 }
42522 arg1 = reinterpret_cast< wxMenu * >(argp1);
42523 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42524 if (!SWIG_IsOK(res2)) {
42525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (wxMenuItem *)(arg1)->Append(arg2);
42530 wxPyEndAllowThreads(__tstate);
42531 if (PyErr_Occurred()) SWIG_fail;
42532 }
42533 {
42534 resultobj = wxPyMake_wxObject(result, (bool)0);
42535 }
42536 return resultobj;
42537 fail:
42538 return NULL;
42539 }
42540
42541
42542 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42543 PyObject *resultobj = 0;
42544 wxMenu *arg1 = (wxMenu *) 0 ;
42545 size_t arg2 ;
42546 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42547 wxMenuItem *result = 0 ;
42548 void *argp1 = 0 ;
42549 int res1 = 0 ;
42550 size_t val2 ;
42551 int ecode2 = 0 ;
42552 int res3 = 0 ;
42553 PyObject * obj0 = 0 ;
42554 PyObject * obj1 = 0 ;
42555 PyObject * obj2 = 0 ;
42556 char * kwnames[] = {
42557 (char *) "self",(char *) "pos",(char *) "item", NULL
42558 };
42559
42560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42562 if (!SWIG_IsOK(res1)) {
42563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42564 }
42565 arg1 = reinterpret_cast< wxMenu * >(argp1);
42566 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42567 if (!SWIG_IsOK(ecode2)) {
42568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42569 }
42570 arg2 = static_cast< size_t >(val2);
42571 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42572 if (!SWIG_IsOK(res3)) {
42573 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42574 }
42575 {
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 {
42582 resultobj = wxPyMake_wxObject(result, (bool)0);
42583 }
42584 return resultobj;
42585 fail:
42586 return NULL;
42587 }
42588
42589
42590 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42591 PyObject *resultobj = 0;
42592 wxMenu *arg1 = (wxMenu *) 0 ;
42593 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42594 wxMenuItem *result = 0 ;
42595 void *argp1 = 0 ;
42596 int res1 = 0 ;
42597 int res2 = 0 ;
42598 PyObject * obj0 = 0 ;
42599 PyObject * obj1 = 0 ;
42600 char * kwnames[] = {
42601 (char *) "self",(char *) "item", NULL
42602 };
42603
42604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42606 if (!SWIG_IsOK(res1)) {
42607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42608 }
42609 arg1 = reinterpret_cast< wxMenu * >(argp1);
42610 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42611 if (!SWIG_IsOK(res2)) {
42612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42613 }
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 resultobj = wxPyMake_wxObject(result, (bool)0);
42622 }
42623 return resultobj;
42624 fail:
42625 return NULL;
42626 }
42627
42628
42629 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42630 PyObject *resultobj = 0;
42631 wxMenu *arg1 = (wxMenu *) 0 ;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 PyObject *swig_obj[1] ;
42635
42636 if (!args) SWIG_fail;
42637 swig_obj[0] = args;
42638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42639 if (!SWIG_IsOK(res1)) {
42640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenu * >(argp1);
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 (arg1)->Break();
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 resultobj = SWIG_Py_Void();
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42657 PyObject *resultobj = 0;
42658 wxMenu *arg1 = (wxMenu *) 0 ;
42659 size_t arg2 ;
42660 int arg3 ;
42661 wxString const &arg4_defvalue = wxPyEmptyString ;
42662 wxString *arg4 = (wxString *) &arg4_defvalue ;
42663 wxString const &arg5_defvalue = wxPyEmptyString ;
42664 wxString *arg5 = (wxString *) &arg5_defvalue ;
42665 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42666 wxMenuItem *result = 0 ;
42667 void *argp1 = 0 ;
42668 int res1 = 0 ;
42669 size_t val2 ;
42670 int ecode2 = 0 ;
42671 int val3 ;
42672 int ecode3 = 0 ;
42673 bool temp4 = false ;
42674 bool temp5 = false ;
42675 int val6 ;
42676 int ecode6 = 0 ;
42677 PyObject * obj0 = 0 ;
42678 PyObject * obj1 = 0 ;
42679 PyObject * obj2 = 0 ;
42680 PyObject * obj3 = 0 ;
42681 PyObject * obj4 = 0 ;
42682 PyObject * obj5 = 0 ;
42683 char * kwnames[] = {
42684 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42685 };
42686
42687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42689 if (!SWIG_IsOK(res1)) {
42690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42691 }
42692 arg1 = reinterpret_cast< wxMenu * >(argp1);
42693 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42694 if (!SWIG_IsOK(ecode2)) {
42695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42696 }
42697 arg2 = static_cast< size_t >(val2);
42698 ecode3 = SWIG_AsVal_int(obj2, &val3);
42699 if (!SWIG_IsOK(ecode3)) {
42700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42701 }
42702 arg3 = static_cast< int >(val3);
42703 if (obj3) {
42704 {
42705 arg4 = wxString_in_helper(obj3);
42706 if (arg4 == NULL) SWIG_fail;
42707 temp4 = true;
42708 }
42709 }
42710 if (obj4) {
42711 {
42712 arg5 = wxString_in_helper(obj4);
42713 if (arg5 == NULL) SWIG_fail;
42714 temp5 = true;
42715 }
42716 }
42717 if (obj5) {
42718 ecode6 = SWIG_AsVal_int(obj5, &val6);
42719 if (!SWIG_IsOK(ecode6)) {
42720 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42721 }
42722 arg6 = static_cast< wxItemKind >(val6);
42723 }
42724 {
42725 PyThreadState* __tstate = wxPyBeginAllowThreads();
42726 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 {
42731 resultobj = wxPyMake_wxObject(result, (bool)0);
42732 }
42733 {
42734 if (temp4)
42735 delete arg4;
42736 }
42737 {
42738 if (temp5)
42739 delete arg5;
42740 }
42741 return resultobj;
42742 fail:
42743 {
42744 if (temp4)
42745 delete arg4;
42746 }
42747 {
42748 if (temp5)
42749 delete arg5;
42750 }
42751 return NULL;
42752 }
42753
42754
42755 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42756 PyObject *resultobj = 0;
42757 wxMenu *arg1 = (wxMenu *) 0 ;
42758 size_t arg2 ;
42759 wxMenuItem *result = 0 ;
42760 void *argp1 = 0 ;
42761 int res1 = 0 ;
42762 size_t val2 ;
42763 int ecode2 = 0 ;
42764 PyObject * obj0 = 0 ;
42765 PyObject * obj1 = 0 ;
42766 char * kwnames[] = {
42767 (char *) "self",(char *) "pos", NULL
42768 };
42769
42770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42772 if (!SWIG_IsOK(res1)) {
42773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42774 }
42775 arg1 = reinterpret_cast< wxMenu * >(argp1);
42776 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42777 if (!SWIG_IsOK(ecode2)) {
42778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42779 }
42780 arg2 = static_cast< size_t >(val2);
42781 {
42782 PyThreadState* __tstate = wxPyBeginAllowThreads();
42783 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42784 wxPyEndAllowThreads(__tstate);
42785 if (PyErr_Occurred()) SWIG_fail;
42786 }
42787 {
42788 resultobj = wxPyMake_wxObject(result, (bool)0);
42789 }
42790 return resultobj;
42791 fail:
42792 return NULL;
42793 }
42794
42795
42796 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42797 PyObject *resultobj = 0;
42798 wxMenu *arg1 = (wxMenu *) 0 ;
42799 size_t arg2 ;
42800 int arg3 ;
42801 wxString *arg4 = 0 ;
42802 wxString const &arg5_defvalue = wxPyEmptyString ;
42803 wxString *arg5 = (wxString *) &arg5_defvalue ;
42804 wxMenuItem *result = 0 ;
42805 void *argp1 = 0 ;
42806 int res1 = 0 ;
42807 size_t val2 ;
42808 int ecode2 = 0 ;
42809 int val3 ;
42810 int ecode3 = 0 ;
42811 bool temp4 = false ;
42812 bool temp5 = false ;
42813 PyObject * obj0 = 0 ;
42814 PyObject * obj1 = 0 ;
42815 PyObject * obj2 = 0 ;
42816 PyObject * obj3 = 0 ;
42817 PyObject * obj4 = 0 ;
42818 char * kwnames[] = {
42819 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42820 };
42821
42822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42824 if (!SWIG_IsOK(res1)) {
42825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42826 }
42827 arg1 = reinterpret_cast< wxMenu * >(argp1);
42828 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42829 if (!SWIG_IsOK(ecode2)) {
42830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42831 }
42832 arg2 = static_cast< size_t >(val2);
42833 ecode3 = SWIG_AsVal_int(obj2, &val3);
42834 if (!SWIG_IsOK(ecode3)) {
42835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42836 }
42837 arg3 = static_cast< int >(val3);
42838 {
42839 arg4 = wxString_in_helper(obj3);
42840 if (arg4 == NULL) SWIG_fail;
42841 temp4 = true;
42842 }
42843 if (obj4) {
42844 {
42845 arg5 = wxString_in_helper(obj4);
42846 if (arg5 == NULL) SWIG_fail;
42847 temp5 = true;
42848 }
42849 }
42850 {
42851 PyThreadState* __tstate = wxPyBeginAllowThreads();
42852 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42853 wxPyEndAllowThreads(__tstate);
42854 if (PyErr_Occurred()) SWIG_fail;
42855 }
42856 {
42857 resultobj = wxPyMake_wxObject(result, (bool)0);
42858 }
42859 {
42860 if (temp4)
42861 delete arg4;
42862 }
42863 {
42864 if (temp5)
42865 delete arg5;
42866 }
42867 return resultobj;
42868 fail:
42869 {
42870 if (temp4)
42871 delete arg4;
42872 }
42873 {
42874 if (temp5)
42875 delete arg5;
42876 }
42877 return NULL;
42878 }
42879
42880
42881 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42882 PyObject *resultobj = 0;
42883 wxMenu *arg1 = (wxMenu *) 0 ;
42884 size_t arg2 ;
42885 int arg3 ;
42886 wxString *arg4 = 0 ;
42887 wxString const &arg5_defvalue = wxPyEmptyString ;
42888 wxString *arg5 = (wxString *) &arg5_defvalue ;
42889 wxMenuItem *result = 0 ;
42890 void *argp1 = 0 ;
42891 int res1 = 0 ;
42892 size_t val2 ;
42893 int ecode2 = 0 ;
42894 int val3 ;
42895 int ecode3 = 0 ;
42896 bool temp4 = false ;
42897 bool temp5 = false ;
42898 PyObject * obj0 = 0 ;
42899 PyObject * obj1 = 0 ;
42900 PyObject * obj2 = 0 ;
42901 PyObject * obj3 = 0 ;
42902 PyObject * obj4 = 0 ;
42903 char * kwnames[] = {
42904 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42905 };
42906
42907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42909 if (!SWIG_IsOK(res1)) {
42910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42911 }
42912 arg1 = reinterpret_cast< wxMenu * >(argp1);
42913 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42914 if (!SWIG_IsOK(ecode2)) {
42915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42916 }
42917 arg2 = static_cast< size_t >(val2);
42918 ecode3 = SWIG_AsVal_int(obj2, &val3);
42919 if (!SWIG_IsOK(ecode3)) {
42920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42921 }
42922 arg3 = static_cast< int >(val3);
42923 {
42924 arg4 = wxString_in_helper(obj3);
42925 if (arg4 == NULL) SWIG_fail;
42926 temp4 = true;
42927 }
42928 if (obj4) {
42929 {
42930 arg5 = wxString_in_helper(obj4);
42931 if (arg5 == NULL) SWIG_fail;
42932 temp5 = true;
42933 }
42934 }
42935 {
42936 PyThreadState* __tstate = wxPyBeginAllowThreads();
42937 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42938 wxPyEndAllowThreads(__tstate);
42939 if (PyErr_Occurred()) SWIG_fail;
42940 }
42941 {
42942 resultobj = wxPyMake_wxObject(result, (bool)0);
42943 }
42944 {
42945 if (temp4)
42946 delete arg4;
42947 }
42948 {
42949 if (temp5)
42950 delete arg5;
42951 }
42952 return resultobj;
42953 fail:
42954 {
42955 if (temp4)
42956 delete arg4;
42957 }
42958 {
42959 if (temp5)
42960 delete arg5;
42961 }
42962 return NULL;
42963 }
42964
42965
42966 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42967 PyObject *resultobj = 0;
42968 wxMenu *arg1 = (wxMenu *) 0 ;
42969 size_t arg2 ;
42970 int arg3 ;
42971 wxString *arg4 = 0 ;
42972 wxMenu *arg5 = (wxMenu *) 0 ;
42973 wxString const &arg6_defvalue = wxPyEmptyString ;
42974 wxString *arg6 = (wxString *) &arg6_defvalue ;
42975 wxMenuItem *result = 0 ;
42976 void *argp1 = 0 ;
42977 int res1 = 0 ;
42978 size_t val2 ;
42979 int ecode2 = 0 ;
42980 int val3 ;
42981 int ecode3 = 0 ;
42982 bool temp4 = false ;
42983 void *argp5 = 0 ;
42984 int res5 = 0 ;
42985 bool temp6 = false ;
42986 PyObject * obj0 = 0 ;
42987 PyObject * obj1 = 0 ;
42988 PyObject * obj2 = 0 ;
42989 PyObject * obj3 = 0 ;
42990 PyObject * obj4 = 0 ;
42991 PyObject * obj5 = 0 ;
42992 char * kwnames[] = {
42993 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42994 };
42995
42996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42998 if (!SWIG_IsOK(res1)) {
42999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43000 }
43001 arg1 = reinterpret_cast< wxMenu * >(argp1);
43002 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43003 if (!SWIG_IsOK(ecode2)) {
43004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43005 }
43006 arg2 = static_cast< size_t >(val2);
43007 ecode3 = SWIG_AsVal_int(obj2, &val3);
43008 if (!SWIG_IsOK(ecode3)) {
43009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43010 }
43011 arg3 = static_cast< int >(val3);
43012 {
43013 arg4 = wxString_in_helper(obj3);
43014 if (arg4 == NULL) SWIG_fail;
43015 temp4 = true;
43016 }
43017 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43018 if (!SWIG_IsOK(res5)) {
43019 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43020 }
43021 arg5 = reinterpret_cast< wxMenu * >(argp5);
43022 if (obj5) {
43023 {
43024 arg6 = wxString_in_helper(obj5);
43025 if (arg6 == NULL) SWIG_fail;
43026 temp6 = true;
43027 }
43028 }
43029 {
43030 PyThreadState* __tstate = wxPyBeginAllowThreads();
43031 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43032 wxPyEndAllowThreads(__tstate);
43033 if (PyErr_Occurred()) SWIG_fail;
43034 }
43035 {
43036 resultobj = wxPyMake_wxObject(result, (bool)0);
43037 }
43038 {
43039 if (temp4)
43040 delete arg4;
43041 }
43042 {
43043 if (temp6)
43044 delete arg6;
43045 }
43046 return resultobj;
43047 fail:
43048 {
43049 if (temp4)
43050 delete arg4;
43051 }
43052 {
43053 if (temp6)
43054 delete arg6;
43055 }
43056 return NULL;
43057 }
43058
43059
43060 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43061 PyObject *resultobj = 0;
43062 wxMenu *arg1 = (wxMenu *) 0 ;
43063 int arg2 ;
43064 wxString const &arg3_defvalue = wxPyEmptyString ;
43065 wxString *arg3 = (wxString *) &arg3_defvalue ;
43066 wxString const &arg4_defvalue = wxPyEmptyString ;
43067 wxString *arg4 = (wxString *) &arg4_defvalue ;
43068 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43069 wxMenuItem *result = 0 ;
43070 void *argp1 = 0 ;
43071 int res1 = 0 ;
43072 int val2 ;
43073 int ecode2 = 0 ;
43074 bool temp3 = false ;
43075 bool temp4 = false ;
43076 int val5 ;
43077 int ecode5 = 0 ;
43078 PyObject * obj0 = 0 ;
43079 PyObject * obj1 = 0 ;
43080 PyObject * obj2 = 0 ;
43081 PyObject * obj3 = 0 ;
43082 PyObject * obj4 = 0 ;
43083 char * kwnames[] = {
43084 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43085 };
43086
43087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43089 if (!SWIG_IsOK(res1)) {
43090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43091 }
43092 arg1 = reinterpret_cast< wxMenu * >(argp1);
43093 ecode2 = SWIG_AsVal_int(obj1, &val2);
43094 if (!SWIG_IsOK(ecode2)) {
43095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43096 }
43097 arg2 = static_cast< int >(val2);
43098 if (obj2) {
43099 {
43100 arg3 = wxString_in_helper(obj2);
43101 if (arg3 == NULL) SWIG_fail;
43102 temp3 = true;
43103 }
43104 }
43105 if (obj3) {
43106 {
43107 arg4 = wxString_in_helper(obj3);
43108 if (arg4 == NULL) SWIG_fail;
43109 temp4 = true;
43110 }
43111 }
43112 if (obj4) {
43113 ecode5 = SWIG_AsVal_int(obj4, &val5);
43114 if (!SWIG_IsOK(ecode5)) {
43115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43116 }
43117 arg5 = static_cast< wxItemKind >(val5);
43118 }
43119 {
43120 PyThreadState* __tstate = wxPyBeginAllowThreads();
43121 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43122 wxPyEndAllowThreads(__tstate);
43123 if (PyErr_Occurred()) SWIG_fail;
43124 }
43125 {
43126 resultobj = wxPyMake_wxObject(result, (bool)0);
43127 }
43128 {
43129 if (temp3)
43130 delete arg3;
43131 }
43132 {
43133 if (temp4)
43134 delete arg4;
43135 }
43136 return resultobj;
43137 fail:
43138 {
43139 if (temp3)
43140 delete arg3;
43141 }
43142 {
43143 if (temp4)
43144 delete arg4;
43145 }
43146 return NULL;
43147 }
43148
43149
43150 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43151 PyObject *resultobj = 0;
43152 wxMenu *arg1 = (wxMenu *) 0 ;
43153 wxMenuItem *result = 0 ;
43154 void *argp1 = 0 ;
43155 int res1 = 0 ;
43156 PyObject *swig_obj[1] ;
43157
43158 if (!args) SWIG_fail;
43159 swig_obj[0] = args;
43160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43161 if (!SWIG_IsOK(res1)) {
43162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43163 }
43164 arg1 = reinterpret_cast< wxMenu * >(argp1);
43165 {
43166 PyThreadState* __tstate = wxPyBeginAllowThreads();
43167 result = (wxMenuItem *)(arg1)->PrependSeparator();
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 {
43172 resultobj = wxPyMake_wxObject(result, (bool)0);
43173 }
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43181 PyObject *resultobj = 0;
43182 wxMenu *arg1 = (wxMenu *) 0 ;
43183 int arg2 ;
43184 wxString *arg3 = 0 ;
43185 wxString const &arg4_defvalue = wxPyEmptyString ;
43186 wxString *arg4 = (wxString *) &arg4_defvalue ;
43187 wxMenuItem *result = 0 ;
43188 void *argp1 = 0 ;
43189 int res1 = 0 ;
43190 int val2 ;
43191 int ecode2 = 0 ;
43192 bool temp3 = false ;
43193 bool temp4 = false ;
43194 PyObject * obj0 = 0 ;
43195 PyObject * obj1 = 0 ;
43196 PyObject * obj2 = 0 ;
43197 PyObject * obj3 = 0 ;
43198 char * kwnames[] = {
43199 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43200 };
43201
43202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43204 if (!SWIG_IsOK(res1)) {
43205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43206 }
43207 arg1 = reinterpret_cast< wxMenu * >(argp1);
43208 ecode2 = SWIG_AsVal_int(obj1, &val2);
43209 if (!SWIG_IsOK(ecode2)) {
43210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43211 }
43212 arg2 = static_cast< int >(val2);
43213 {
43214 arg3 = wxString_in_helper(obj2);
43215 if (arg3 == NULL) SWIG_fail;
43216 temp3 = true;
43217 }
43218 if (obj3) {
43219 {
43220 arg4 = wxString_in_helper(obj3);
43221 if (arg4 == NULL) SWIG_fail;
43222 temp4 = true;
43223 }
43224 }
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 {
43232 resultobj = wxPyMake_wxObject(result, (bool)0);
43233 }
43234 {
43235 if (temp3)
43236 delete arg3;
43237 }
43238 {
43239 if (temp4)
43240 delete arg4;
43241 }
43242 return resultobj;
43243 fail:
43244 {
43245 if (temp3)
43246 delete arg3;
43247 }
43248 {
43249 if (temp4)
43250 delete arg4;
43251 }
43252 return NULL;
43253 }
43254
43255
43256 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43257 PyObject *resultobj = 0;
43258 wxMenu *arg1 = (wxMenu *) 0 ;
43259 int arg2 ;
43260 wxString *arg3 = 0 ;
43261 wxString const &arg4_defvalue = wxPyEmptyString ;
43262 wxString *arg4 = (wxString *) &arg4_defvalue ;
43263 wxMenuItem *result = 0 ;
43264 void *argp1 = 0 ;
43265 int res1 = 0 ;
43266 int val2 ;
43267 int ecode2 = 0 ;
43268 bool temp3 = false ;
43269 bool temp4 = false ;
43270 PyObject * obj0 = 0 ;
43271 PyObject * obj1 = 0 ;
43272 PyObject * obj2 = 0 ;
43273 PyObject * obj3 = 0 ;
43274 char * kwnames[] = {
43275 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43276 };
43277
43278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43280 if (!SWIG_IsOK(res1)) {
43281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43282 }
43283 arg1 = reinterpret_cast< wxMenu * >(argp1);
43284 ecode2 = SWIG_AsVal_int(obj1, &val2);
43285 if (!SWIG_IsOK(ecode2)) {
43286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43287 }
43288 arg2 = static_cast< int >(val2);
43289 {
43290 arg3 = wxString_in_helper(obj2);
43291 if (arg3 == NULL) SWIG_fail;
43292 temp3 = true;
43293 }
43294 if (obj3) {
43295 {
43296 arg4 = wxString_in_helper(obj3);
43297 if (arg4 == NULL) SWIG_fail;
43298 temp4 = true;
43299 }
43300 }
43301 {
43302 PyThreadState* __tstate = wxPyBeginAllowThreads();
43303 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 {
43308 resultobj = wxPyMake_wxObject(result, (bool)0);
43309 }
43310 {
43311 if (temp3)
43312 delete arg3;
43313 }
43314 {
43315 if (temp4)
43316 delete arg4;
43317 }
43318 return resultobj;
43319 fail:
43320 {
43321 if (temp3)
43322 delete arg3;
43323 }
43324 {
43325 if (temp4)
43326 delete arg4;
43327 }
43328 return NULL;
43329 }
43330
43331
43332 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43333 PyObject *resultobj = 0;
43334 wxMenu *arg1 = (wxMenu *) 0 ;
43335 int arg2 ;
43336 wxString *arg3 = 0 ;
43337 wxMenu *arg4 = (wxMenu *) 0 ;
43338 wxString const &arg5_defvalue = wxPyEmptyString ;
43339 wxString *arg5 = (wxString *) &arg5_defvalue ;
43340 wxMenuItem *result = 0 ;
43341 void *argp1 = 0 ;
43342 int res1 = 0 ;
43343 int val2 ;
43344 int ecode2 = 0 ;
43345 bool temp3 = false ;
43346 void *argp4 = 0 ;
43347 int res4 = 0 ;
43348 bool temp5 = false ;
43349 PyObject * obj0 = 0 ;
43350 PyObject * obj1 = 0 ;
43351 PyObject * obj2 = 0 ;
43352 PyObject * obj3 = 0 ;
43353 PyObject * obj4 = 0 ;
43354 char * kwnames[] = {
43355 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43356 };
43357
43358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43360 if (!SWIG_IsOK(res1)) {
43361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43362 }
43363 arg1 = reinterpret_cast< wxMenu * >(argp1);
43364 ecode2 = SWIG_AsVal_int(obj1, &val2);
43365 if (!SWIG_IsOK(ecode2)) {
43366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43367 }
43368 arg2 = static_cast< int >(val2);
43369 {
43370 arg3 = wxString_in_helper(obj2);
43371 if (arg3 == NULL) SWIG_fail;
43372 temp3 = true;
43373 }
43374 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43375 if (!SWIG_IsOK(res4)) {
43376 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43377 }
43378 arg4 = reinterpret_cast< wxMenu * >(argp4);
43379 if (obj4) {
43380 {
43381 arg5 = wxString_in_helper(obj4);
43382 if (arg5 == NULL) SWIG_fail;
43383 temp5 = true;
43384 }
43385 }
43386 {
43387 PyThreadState* __tstate = wxPyBeginAllowThreads();
43388 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43389 wxPyEndAllowThreads(__tstate);
43390 if (PyErr_Occurred()) SWIG_fail;
43391 }
43392 {
43393 resultobj = wxPyMake_wxObject(result, (bool)0);
43394 }
43395 {
43396 if (temp3)
43397 delete arg3;
43398 }
43399 {
43400 if (temp5)
43401 delete arg5;
43402 }
43403 return resultobj;
43404 fail:
43405 {
43406 if (temp3)
43407 delete arg3;
43408 }
43409 {
43410 if (temp5)
43411 delete arg5;
43412 }
43413 return NULL;
43414 }
43415
43416
43417 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43418 PyObject *resultobj = 0;
43419 wxMenu *arg1 = (wxMenu *) 0 ;
43420 int arg2 ;
43421 wxMenuItem *result = 0 ;
43422 void *argp1 = 0 ;
43423 int res1 = 0 ;
43424 int val2 ;
43425 int ecode2 = 0 ;
43426 PyObject * obj0 = 0 ;
43427 PyObject * obj1 = 0 ;
43428 char * kwnames[] = {
43429 (char *) "self",(char *) "id", NULL
43430 };
43431
43432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43434 if (!SWIG_IsOK(res1)) {
43435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43436 }
43437 arg1 = reinterpret_cast< wxMenu * >(argp1);
43438 ecode2 = SWIG_AsVal_int(obj1, &val2);
43439 if (!SWIG_IsOK(ecode2)) {
43440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43441 }
43442 arg2 = static_cast< int >(val2);
43443 {
43444 PyThreadState* __tstate = wxPyBeginAllowThreads();
43445 result = (wxMenuItem *)(arg1)->Remove(arg2);
43446 wxPyEndAllowThreads(__tstate);
43447 if (PyErr_Occurred()) SWIG_fail;
43448 }
43449 {
43450 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43451 }
43452 return resultobj;
43453 fail:
43454 return NULL;
43455 }
43456
43457
43458 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43459 PyObject *resultobj = 0;
43460 wxMenu *arg1 = (wxMenu *) 0 ;
43461 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43462 wxMenuItem *result = 0 ;
43463 void *argp1 = 0 ;
43464 int res1 = 0 ;
43465 void *argp2 = 0 ;
43466 int res2 = 0 ;
43467 PyObject * obj0 = 0 ;
43468 PyObject * obj1 = 0 ;
43469 char * kwnames[] = {
43470 (char *) "self",(char *) "item", NULL
43471 };
43472
43473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43475 if (!SWIG_IsOK(res1)) {
43476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43477 }
43478 arg1 = reinterpret_cast< wxMenu * >(argp1);
43479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43480 if (!SWIG_IsOK(res2)) {
43481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43482 }
43483 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43484 {
43485 PyThreadState* __tstate = wxPyBeginAllowThreads();
43486 result = (wxMenuItem *)(arg1)->Remove(arg2);
43487 wxPyEndAllowThreads(__tstate);
43488 if (PyErr_Occurred()) SWIG_fail;
43489 }
43490 {
43491 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43492 }
43493 return resultobj;
43494 fail:
43495 return NULL;
43496 }
43497
43498
43499 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43500 PyObject *resultobj = 0;
43501 wxMenu *arg1 = (wxMenu *) 0 ;
43502 int arg2 ;
43503 bool result;
43504 void *argp1 = 0 ;
43505 int res1 = 0 ;
43506 int val2 ;
43507 int ecode2 = 0 ;
43508 PyObject * obj0 = 0 ;
43509 PyObject * obj1 = 0 ;
43510 char * kwnames[] = {
43511 (char *) "self",(char *) "id", NULL
43512 };
43513
43514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43516 if (!SWIG_IsOK(res1)) {
43517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43518 }
43519 arg1 = reinterpret_cast< wxMenu * >(argp1);
43520 ecode2 = SWIG_AsVal_int(obj1, &val2);
43521 if (!SWIG_IsOK(ecode2)) {
43522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43523 }
43524 arg2 = static_cast< int >(val2);
43525 {
43526 PyThreadState* __tstate = wxPyBeginAllowThreads();
43527 result = (bool)(arg1)->Delete(arg2);
43528 wxPyEndAllowThreads(__tstate);
43529 if (PyErr_Occurred()) SWIG_fail;
43530 }
43531 {
43532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43533 }
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43541 PyObject *resultobj = 0;
43542 wxMenu *arg1 = (wxMenu *) 0 ;
43543 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43544 bool result;
43545 void *argp1 = 0 ;
43546 int res1 = 0 ;
43547 void *argp2 = 0 ;
43548 int res2 = 0 ;
43549 PyObject * obj0 = 0 ;
43550 PyObject * obj1 = 0 ;
43551 char * kwnames[] = {
43552 (char *) "self",(char *) "item", NULL
43553 };
43554
43555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43557 if (!SWIG_IsOK(res1)) {
43558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43559 }
43560 arg1 = reinterpret_cast< wxMenu * >(argp1);
43561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43562 if (!SWIG_IsOK(res2)) {
43563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43564 }
43565 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43566 {
43567 PyThreadState* __tstate = wxPyBeginAllowThreads();
43568 result = (bool)(arg1)->Delete(arg2);
43569 wxPyEndAllowThreads(__tstate);
43570 if (PyErr_Occurred()) SWIG_fail;
43571 }
43572 {
43573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43574 }
43575 return resultobj;
43576 fail:
43577 return NULL;
43578 }
43579
43580
43581 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43582 PyObject *resultobj = 0;
43583 wxMenu *arg1 = (wxMenu *) 0 ;
43584 void *argp1 = 0 ;
43585 int res1 = 0 ;
43586 PyObject *swig_obj[1] ;
43587
43588 if (!args) SWIG_fail;
43589 swig_obj[0] = args;
43590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43591 if (!SWIG_IsOK(res1)) {
43592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43593 }
43594 arg1 = reinterpret_cast< wxMenu * >(argp1);
43595 {
43596 PyThreadState* __tstate = wxPyBeginAllowThreads();
43597 wxMenu_Destroy(arg1);
43598 wxPyEndAllowThreads(__tstate);
43599 if (PyErr_Occurred()) SWIG_fail;
43600 }
43601 resultobj = SWIG_Py_Void();
43602 return resultobj;
43603 fail:
43604 return NULL;
43605 }
43606
43607
43608 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43609 PyObject *resultobj = 0;
43610 wxMenu *arg1 = (wxMenu *) 0 ;
43611 int arg2 ;
43612 bool result;
43613 void *argp1 = 0 ;
43614 int res1 = 0 ;
43615 int val2 ;
43616 int ecode2 = 0 ;
43617 PyObject * obj0 = 0 ;
43618 PyObject * obj1 = 0 ;
43619 char * kwnames[] = {
43620 (char *) "self",(char *) "id", NULL
43621 };
43622
43623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43625 if (!SWIG_IsOK(res1)) {
43626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43627 }
43628 arg1 = reinterpret_cast< wxMenu * >(argp1);
43629 ecode2 = SWIG_AsVal_int(obj1, &val2);
43630 if (!SWIG_IsOK(ecode2)) {
43631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43632 }
43633 arg2 = static_cast< int >(val2);
43634 {
43635 PyThreadState* __tstate = wxPyBeginAllowThreads();
43636 result = (bool)(arg1)->Destroy(arg2);
43637 wxPyEndAllowThreads(__tstate);
43638 if (PyErr_Occurred()) SWIG_fail;
43639 }
43640 {
43641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43642 }
43643 return resultobj;
43644 fail:
43645 return NULL;
43646 }
43647
43648
43649 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43650 PyObject *resultobj = 0;
43651 wxMenu *arg1 = (wxMenu *) 0 ;
43652 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43653 bool result;
43654 void *argp1 = 0 ;
43655 int res1 = 0 ;
43656 void *argp2 = 0 ;
43657 int res2 = 0 ;
43658 PyObject * obj0 = 0 ;
43659 PyObject * obj1 = 0 ;
43660 char * kwnames[] = {
43661 (char *) "self",(char *) "item", NULL
43662 };
43663
43664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43666 if (!SWIG_IsOK(res1)) {
43667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43668 }
43669 arg1 = reinterpret_cast< wxMenu * >(argp1);
43670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43671 if (!SWIG_IsOK(res2)) {
43672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43673 }
43674 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43675 {
43676 PyThreadState* __tstate = wxPyBeginAllowThreads();
43677 result = (bool)(arg1)->Destroy(arg2);
43678 wxPyEndAllowThreads(__tstate);
43679 if (PyErr_Occurred()) SWIG_fail;
43680 }
43681 {
43682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43683 }
43684 return resultobj;
43685 fail:
43686 return NULL;
43687 }
43688
43689
43690 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43691 PyObject *resultobj = 0;
43692 wxMenu *arg1 = (wxMenu *) 0 ;
43693 size_t result;
43694 void *argp1 = 0 ;
43695 int res1 = 0 ;
43696 PyObject *swig_obj[1] ;
43697
43698 if (!args) SWIG_fail;
43699 swig_obj[0] = args;
43700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43701 if (!SWIG_IsOK(res1)) {
43702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43703 }
43704 arg1 = reinterpret_cast< wxMenu * >(argp1);
43705 {
43706 PyThreadState* __tstate = wxPyBeginAllowThreads();
43707 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43708 wxPyEndAllowThreads(__tstate);
43709 if (PyErr_Occurred()) SWIG_fail;
43710 }
43711 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43712 return resultobj;
43713 fail:
43714 return NULL;
43715 }
43716
43717
43718 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43719 PyObject *resultobj = 0;
43720 wxMenu *arg1 = (wxMenu *) 0 ;
43721 PyObject *result = 0 ;
43722 void *argp1 = 0 ;
43723 int res1 = 0 ;
43724 PyObject *swig_obj[1] ;
43725
43726 if (!args) SWIG_fail;
43727 swig_obj[0] = args;
43728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43729 if (!SWIG_IsOK(res1)) {
43730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43731 }
43732 arg1 = reinterpret_cast< wxMenu * >(argp1);
43733 {
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43736 wxPyEndAllowThreads(__tstate);
43737 if (PyErr_Occurred()) SWIG_fail;
43738 }
43739 resultobj = result;
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43747 PyObject *resultobj = 0;
43748 wxMenu *arg1 = (wxMenu *) 0 ;
43749 wxString *arg2 = 0 ;
43750 int result;
43751 void *argp1 = 0 ;
43752 int res1 = 0 ;
43753 bool temp2 = false ;
43754 PyObject * obj0 = 0 ;
43755 PyObject * obj1 = 0 ;
43756 char * kwnames[] = {
43757 (char *) "self",(char *) "item", NULL
43758 };
43759
43760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43762 if (!SWIG_IsOK(res1)) {
43763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43764 }
43765 arg1 = reinterpret_cast< wxMenu * >(argp1);
43766 {
43767 arg2 = wxString_in_helper(obj1);
43768 if (arg2 == NULL) SWIG_fail;
43769 temp2 = true;
43770 }
43771 {
43772 PyThreadState* __tstate = wxPyBeginAllowThreads();
43773 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43774 wxPyEndAllowThreads(__tstate);
43775 if (PyErr_Occurred()) SWIG_fail;
43776 }
43777 resultobj = SWIG_From_int(static_cast< int >(result));
43778 {
43779 if (temp2)
43780 delete arg2;
43781 }
43782 return resultobj;
43783 fail:
43784 {
43785 if (temp2)
43786 delete arg2;
43787 }
43788 return NULL;
43789 }
43790
43791
43792 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43793 PyObject *resultobj = 0;
43794 wxMenu *arg1 = (wxMenu *) 0 ;
43795 int arg2 ;
43796 wxMenuItem *result = 0 ;
43797 void *argp1 = 0 ;
43798 int res1 = 0 ;
43799 int val2 ;
43800 int ecode2 = 0 ;
43801 PyObject * obj0 = 0 ;
43802 PyObject * obj1 = 0 ;
43803 char * kwnames[] = {
43804 (char *) "self",(char *) "id", NULL
43805 };
43806
43807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43809 if (!SWIG_IsOK(res1)) {
43810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43811 }
43812 arg1 = reinterpret_cast< wxMenu * >(argp1);
43813 ecode2 = SWIG_AsVal_int(obj1, &val2);
43814 if (!SWIG_IsOK(ecode2)) {
43815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43816 }
43817 arg2 = static_cast< int >(val2);
43818 {
43819 PyThreadState* __tstate = wxPyBeginAllowThreads();
43820 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43821 wxPyEndAllowThreads(__tstate);
43822 if (PyErr_Occurred()) SWIG_fail;
43823 }
43824 {
43825 resultobj = wxPyMake_wxObject(result, (bool)0);
43826 }
43827 return resultobj;
43828 fail:
43829 return NULL;
43830 }
43831
43832
43833 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43834 PyObject *resultobj = 0;
43835 wxMenu *arg1 = (wxMenu *) 0 ;
43836 size_t arg2 ;
43837 wxMenuItem *result = 0 ;
43838 void *argp1 = 0 ;
43839 int res1 = 0 ;
43840 size_t val2 ;
43841 int ecode2 = 0 ;
43842 PyObject * obj0 = 0 ;
43843 PyObject * obj1 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "self",(char *) "position", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43852 }
43853 arg1 = reinterpret_cast< wxMenu * >(argp1);
43854 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43855 if (!SWIG_IsOK(ecode2)) {
43856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43857 }
43858 arg2 = static_cast< size_t >(val2);
43859 {
43860 PyThreadState* __tstate = wxPyBeginAllowThreads();
43861 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 {
43866 resultobj = wxPyMake_wxObject(result, (bool)0);
43867 }
43868 return resultobj;
43869 fail:
43870 return NULL;
43871 }
43872
43873
43874 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43875 PyObject *resultobj = 0;
43876 wxMenu *arg1 = (wxMenu *) 0 ;
43877 int arg2 ;
43878 bool arg3 ;
43879 void *argp1 = 0 ;
43880 int res1 = 0 ;
43881 int val2 ;
43882 int ecode2 = 0 ;
43883 bool val3 ;
43884 int ecode3 = 0 ;
43885 PyObject * obj0 = 0 ;
43886 PyObject * obj1 = 0 ;
43887 PyObject * obj2 = 0 ;
43888 char * kwnames[] = {
43889 (char *) "self",(char *) "id",(char *) "enable", NULL
43890 };
43891
43892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43894 if (!SWIG_IsOK(res1)) {
43895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43896 }
43897 arg1 = reinterpret_cast< wxMenu * >(argp1);
43898 ecode2 = SWIG_AsVal_int(obj1, &val2);
43899 if (!SWIG_IsOK(ecode2)) {
43900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43901 }
43902 arg2 = static_cast< int >(val2);
43903 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43904 if (!SWIG_IsOK(ecode3)) {
43905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43906 }
43907 arg3 = static_cast< bool >(val3);
43908 {
43909 PyThreadState* __tstate = wxPyBeginAllowThreads();
43910 (arg1)->Enable(arg2,arg3);
43911 wxPyEndAllowThreads(__tstate);
43912 if (PyErr_Occurred()) SWIG_fail;
43913 }
43914 resultobj = SWIG_Py_Void();
43915 return resultobj;
43916 fail:
43917 return NULL;
43918 }
43919
43920
43921 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43922 PyObject *resultobj = 0;
43923 wxMenu *arg1 = (wxMenu *) 0 ;
43924 int arg2 ;
43925 bool result;
43926 void *argp1 = 0 ;
43927 int res1 = 0 ;
43928 int val2 ;
43929 int ecode2 = 0 ;
43930 PyObject * obj0 = 0 ;
43931 PyObject * obj1 = 0 ;
43932 char * kwnames[] = {
43933 (char *) "self",(char *) "id", NULL
43934 };
43935
43936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43938 if (!SWIG_IsOK(res1)) {
43939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43940 }
43941 arg1 = reinterpret_cast< wxMenu * >(argp1);
43942 ecode2 = SWIG_AsVal_int(obj1, &val2);
43943 if (!SWIG_IsOK(ecode2)) {
43944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43945 }
43946 arg2 = static_cast< int >(val2);
43947 {
43948 PyThreadState* __tstate = wxPyBeginAllowThreads();
43949 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43950 wxPyEndAllowThreads(__tstate);
43951 if (PyErr_Occurred()) SWIG_fail;
43952 }
43953 {
43954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43955 }
43956 return resultobj;
43957 fail:
43958 return NULL;
43959 }
43960
43961
43962 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43963 PyObject *resultobj = 0;
43964 wxMenu *arg1 = (wxMenu *) 0 ;
43965 int arg2 ;
43966 bool arg3 ;
43967 void *argp1 = 0 ;
43968 int res1 = 0 ;
43969 int val2 ;
43970 int ecode2 = 0 ;
43971 bool val3 ;
43972 int ecode3 = 0 ;
43973 PyObject * obj0 = 0 ;
43974 PyObject * obj1 = 0 ;
43975 PyObject * obj2 = 0 ;
43976 char * kwnames[] = {
43977 (char *) "self",(char *) "id",(char *) "check", NULL
43978 };
43979
43980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43982 if (!SWIG_IsOK(res1)) {
43983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43984 }
43985 arg1 = reinterpret_cast< wxMenu * >(argp1);
43986 ecode2 = SWIG_AsVal_int(obj1, &val2);
43987 if (!SWIG_IsOK(ecode2)) {
43988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43989 }
43990 arg2 = static_cast< int >(val2);
43991 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43992 if (!SWIG_IsOK(ecode3)) {
43993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43994 }
43995 arg3 = static_cast< bool >(val3);
43996 {
43997 PyThreadState* __tstate = wxPyBeginAllowThreads();
43998 (arg1)->Check(arg2,arg3);
43999 wxPyEndAllowThreads(__tstate);
44000 if (PyErr_Occurred()) SWIG_fail;
44001 }
44002 resultobj = SWIG_Py_Void();
44003 return resultobj;
44004 fail:
44005 return NULL;
44006 }
44007
44008
44009 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44010 PyObject *resultobj = 0;
44011 wxMenu *arg1 = (wxMenu *) 0 ;
44012 int arg2 ;
44013 bool result;
44014 void *argp1 = 0 ;
44015 int res1 = 0 ;
44016 int val2 ;
44017 int ecode2 = 0 ;
44018 PyObject * obj0 = 0 ;
44019 PyObject * obj1 = 0 ;
44020 char * kwnames[] = {
44021 (char *) "self",(char *) "id", NULL
44022 };
44023
44024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44026 if (!SWIG_IsOK(res1)) {
44027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44028 }
44029 arg1 = reinterpret_cast< wxMenu * >(argp1);
44030 ecode2 = SWIG_AsVal_int(obj1, &val2);
44031 if (!SWIG_IsOK(ecode2)) {
44032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44033 }
44034 arg2 = static_cast< int >(val2);
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 {
44042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44043 }
44044 return resultobj;
44045 fail:
44046 return NULL;
44047 }
44048
44049
44050 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44051 PyObject *resultobj = 0;
44052 wxMenu *arg1 = (wxMenu *) 0 ;
44053 int arg2 ;
44054 wxString *arg3 = 0 ;
44055 void *argp1 = 0 ;
44056 int res1 = 0 ;
44057 int val2 ;
44058 int ecode2 = 0 ;
44059 bool temp3 = false ;
44060 PyObject * obj0 = 0 ;
44061 PyObject * obj1 = 0 ;
44062 PyObject * obj2 = 0 ;
44063 char * kwnames[] = {
44064 (char *) "self",(char *) "id",(char *) "label", NULL
44065 };
44066
44067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44069 if (!SWIG_IsOK(res1)) {
44070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44071 }
44072 arg1 = reinterpret_cast< wxMenu * >(argp1);
44073 ecode2 = SWIG_AsVal_int(obj1, &val2);
44074 if (!SWIG_IsOK(ecode2)) {
44075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44076 }
44077 arg2 = static_cast< int >(val2);
44078 {
44079 arg3 = wxString_in_helper(obj2);
44080 if (arg3 == NULL) SWIG_fail;
44081 temp3 = true;
44082 }
44083 {
44084 PyThreadState* __tstate = wxPyBeginAllowThreads();
44085 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44086 wxPyEndAllowThreads(__tstate);
44087 if (PyErr_Occurred()) SWIG_fail;
44088 }
44089 resultobj = SWIG_Py_Void();
44090 {
44091 if (temp3)
44092 delete arg3;
44093 }
44094 return resultobj;
44095 fail:
44096 {
44097 if (temp3)
44098 delete arg3;
44099 }
44100 return NULL;
44101 }
44102
44103
44104 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44105 PyObject *resultobj = 0;
44106 wxMenu *arg1 = (wxMenu *) 0 ;
44107 int arg2 ;
44108 wxString result;
44109 void *argp1 = 0 ;
44110 int res1 = 0 ;
44111 int val2 ;
44112 int ecode2 = 0 ;
44113 PyObject * obj0 = 0 ;
44114 PyObject * obj1 = 0 ;
44115 char * kwnames[] = {
44116 (char *) "self",(char *) "id", NULL
44117 };
44118
44119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44121 if (!SWIG_IsOK(res1)) {
44122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44123 }
44124 arg1 = reinterpret_cast< wxMenu * >(argp1);
44125 ecode2 = SWIG_AsVal_int(obj1, &val2);
44126 if (!SWIG_IsOK(ecode2)) {
44127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44128 }
44129 arg2 = static_cast< int >(val2);
44130 {
44131 PyThreadState* __tstate = wxPyBeginAllowThreads();
44132 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 {
44137 #if wxUSE_UNICODE
44138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44139 #else
44140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44141 #endif
44142 }
44143 return resultobj;
44144 fail:
44145 return NULL;
44146 }
44147
44148
44149 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44150 PyObject *resultobj = 0;
44151 wxMenu *arg1 = (wxMenu *) 0 ;
44152 int arg2 ;
44153 wxString *arg3 = 0 ;
44154 void *argp1 = 0 ;
44155 int res1 = 0 ;
44156 int val2 ;
44157 int ecode2 = 0 ;
44158 bool temp3 = false ;
44159 PyObject * obj0 = 0 ;
44160 PyObject * obj1 = 0 ;
44161 PyObject * obj2 = 0 ;
44162 char * kwnames[] = {
44163 (char *) "self",(char *) "id",(char *) "helpString", NULL
44164 };
44165
44166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44168 if (!SWIG_IsOK(res1)) {
44169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44170 }
44171 arg1 = reinterpret_cast< wxMenu * >(argp1);
44172 ecode2 = SWIG_AsVal_int(obj1, &val2);
44173 if (!SWIG_IsOK(ecode2)) {
44174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44175 }
44176 arg2 = static_cast< int >(val2);
44177 {
44178 arg3 = wxString_in_helper(obj2);
44179 if (arg3 == NULL) SWIG_fail;
44180 temp3 = true;
44181 }
44182 {
44183 PyThreadState* __tstate = wxPyBeginAllowThreads();
44184 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 resultobj = SWIG_Py_Void();
44189 {
44190 if (temp3)
44191 delete arg3;
44192 }
44193 return resultobj;
44194 fail:
44195 {
44196 if (temp3)
44197 delete arg3;
44198 }
44199 return NULL;
44200 }
44201
44202
44203 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44204 PyObject *resultobj = 0;
44205 wxMenu *arg1 = (wxMenu *) 0 ;
44206 int arg2 ;
44207 wxString result;
44208 void *argp1 = 0 ;
44209 int res1 = 0 ;
44210 int val2 ;
44211 int ecode2 = 0 ;
44212 PyObject * obj0 = 0 ;
44213 PyObject * obj1 = 0 ;
44214 char * kwnames[] = {
44215 (char *) "self",(char *) "id", NULL
44216 };
44217
44218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44220 if (!SWIG_IsOK(res1)) {
44221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44222 }
44223 arg1 = reinterpret_cast< wxMenu * >(argp1);
44224 ecode2 = SWIG_AsVal_int(obj1, &val2);
44225 if (!SWIG_IsOK(ecode2)) {
44226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44227 }
44228 arg2 = static_cast< int >(val2);
44229 {
44230 PyThreadState* __tstate = wxPyBeginAllowThreads();
44231 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44232 wxPyEndAllowThreads(__tstate);
44233 if (PyErr_Occurred()) SWIG_fail;
44234 }
44235 {
44236 #if wxUSE_UNICODE
44237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44238 #else
44239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44240 #endif
44241 }
44242 return resultobj;
44243 fail:
44244 return NULL;
44245 }
44246
44247
44248 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44249 PyObject *resultobj = 0;
44250 wxMenu *arg1 = (wxMenu *) 0 ;
44251 wxString *arg2 = 0 ;
44252 void *argp1 = 0 ;
44253 int res1 = 0 ;
44254 bool temp2 = false ;
44255 PyObject * obj0 = 0 ;
44256 PyObject * obj1 = 0 ;
44257 char * kwnames[] = {
44258 (char *) "self",(char *) "title", NULL
44259 };
44260
44261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44263 if (!SWIG_IsOK(res1)) {
44264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44265 }
44266 arg1 = reinterpret_cast< wxMenu * >(argp1);
44267 {
44268 arg2 = wxString_in_helper(obj1);
44269 if (arg2 == NULL) SWIG_fail;
44270 temp2 = true;
44271 }
44272 {
44273 PyThreadState* __tstate = wxPyBeginAllowThreads();
44274 (arg1)->SetTitle((wxString const &)*arg2);
44275 wxPyEndAllowThreads(__tstate);
44276 if (PyErr_Occurred()) SWIG_fail;
44277 }
44278 resultobj = SWIG_Py_Void();
44279 {
44280 if (temp2)
44281 delete arg2;
44282 }
44283 return resultobj;
44284 fail:
44285 {
44286 if (temp2)
44287 delete arg2;
44288 }
44289 return NULL;
44290 }
44291
44292
44293 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44294 PyObject *resultobj = 0;
44295 wxMenu *arg1 = (wxMenu *) 0 ;
44296 wxString result;
44297 void *argp1 = 0 ;
44298 int res1 = 0 ;
44299 PyObject *swig_obj[1] ;
44300
44301 if (!args) SWIG_fail;
44302 swig_obj[0] = args;
44303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44304 if (!SWIG_IsOK(res1)) {
44305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44306 }
44307 arg1 = reinterpret_cast< wxMenu * >(argp1);
44308 {
44309 PyThreadState* __tstate = wxPyBeginAllowThreads();
44310 result = ((wxMenu const *)arg1)->GetTitle();
44311 wxPyEndAllowThreads(__tstate);
44312 if (PyErr_Occurred()) SWIG_fail;
44313 }
44314 {
44315 #if wxUSE_UNICODE
44316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44317 #else
44318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44319 #endif
44320 }
44321 return resultobj;
44322 fail:
44323 return NULL;
44324 }
44325
44326
44327 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44328 PyObject *resultobj = 0;
44329 wxMenu *arg1 = (wxMenu *) 0 ;
44330 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44331 void *argp1 = 0 ;
44332 int res1 = 0 ;
44333 void *argp2 = 0 ;
44334 int res2 = 0 ;
44335 PyObject * obj0 = 0 ;
44336 PyObject * obj1 = 0 ;
44337 char * kwnames[] = {
44338 (char *) "self",(char *) "handler", NULL
44339 };
44340
44341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44343 if (!SWIG_IsOK(res1)) {
44344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44345 }
44346 arg1 = reinterpret_cast< wxMenu * >(argp1);
44347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44348 if (!SWIG_IsOK(res2)) {
44349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44350 }
44351 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 (arg1)->SetEventHandler(arg2);
44355 wxPyEndAllowThreads(__tstate);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 }
44358 resultobj = SWIG_Py_Void();
44359 return resultobj;
44360 fail:
44361 return NULL;
44362 }
44363
44364
44365 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44366 PyObject *resultobj = 0;
44367 wxMenu *arg1 = (wxMenu *) 0 ;
44368 wxEvtHandler *result = 0 ;
44369 void *argp1 = 0 ;
44370 int res1 = 0 ;
44371 PyObject *swig_obj[1] ;
44372
44373 if (!args) SWIG_fail;
44374 swig_obj[0] = args;
44375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenu * >(argp1);
44380 {
44381 PyThreadState* __tstate = wxPyBeginAllowThreads();
44382 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44383 wxPyEndAllowThreads(__tstate);
44384 if (PyErr_Occurred()) SWIG_fail;
44385 }
44386 {
44387 resultobj = wxPyMake_wxObject(result, 0);
44388 }
44389 return resultobj;
44390 fail:
44391 return NULL;
44392 }
44393
44394
44395 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44396 PyObject *resultobj = 0;
44397 wxMenu *arg1 = (wxMenu *) 0 ;
44398 wxWindow *arg2 = (wxWindow *) 0 ;
44399 void *argp1 = 0 ;
44400 int res1 = 0 ;
44401 void *argp2 = 0 ;
44402 int res2 = 0 ;
44403 PyObject * obj0 = 0 ;
44404 PyObject * obj1 = 0 ;
44405 char * kwnames[] = {
44406 (char *) "self",(char *) "win", NULL
44407 };
44408
44409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44411 if (!SWIG_IsOK(res1)) {
44412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44413 }
44414 arg1 = reinterpret_cast< wxMenu * >(argp1);
44415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44416 if (!SWIG_IsOK(res2)) {
44417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44418 }
44419 arg2 = reinterpret_cast< wxWindow * >(argp2);
44420 {
44421 PyThreadState* __tstate = wxPyBeginAllowThreads();
44422 (arg1)->SetInvokingWindow(arg2);
44423 wxPyEndAllowThreads(__tstate);
44424 if (PyErr_Occurred()) SWIG_fail;
44425 }
44426 resultobj = SWIG_Py_Void();
44427 return resultobj;
44428 fail:
44429 return NULL;
44430 }
44431
44432
44433 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44434 PyObject *resultobj = 0;
44435 wxMenu *arg1 = (wxMenu *) 0 ;
44436 wxWindow *result = 0 ;
44437 void *argp1 = 0 ;
44438 int res1 = 0 ;
44439 PyObject *swig_obj[1] ;
44440
44441 if (!args) SWIG_fail;
44442 swig_obj[0] = args;
44443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44444 if (!SWIG_IsOK(res1)) {
44445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44446 }
44447 arg1 = reinterpret_cast< wxMenu * >(argp1);
44448 {
44449 PyThreadState* __tstate = wxPyBeginAllowThreads();
44450 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44451 wxPyEndAllowThreads(__tstate);
44452 if (PyErr_Occurred()) SWIG_fail;
44453 }
44454 {
44455 resultobj = wxPyMake_wxObject(result, 0);
44456 }
44457 return resultobj;
44458 fail:
44459 return NULL;
44460 }
44461
44462
44463 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44464 PyObject *resultobj = 0;
44465 wxMenu *arg1 = (wxMenu *) 0 ;
44466 long result;
44467 void *argp1 = 0 ;
44468 int res1 = 0 ;
44469 PyObject *swig_obj[1] ;
44470
44471 if (!args) SWIG_fail;
44472 swig_obj[0] = args;
44473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44474 if (!SWIG_IsOK(res1)) {
44475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44476 }
44477 arg1 = reinterpret_cast< wxMenu * >(argp1);
44478 {
44479 PyThreadState* __tstate = wxPyBeginAllowThreads();
44480 result = (long)((wxMenu const *)arg1)->GetStyle();
44481 wxPyEndAllowThreads(__tstate);
44482 if (PyErr_Occurred()) SWIG_fail;
44483 }
44484 resultobj = SWIG_From_long(static_cast< long >(result));
44485 return resultobj;
44486 fail:
44487 return NULL;
44488 }
44489
44490
44491 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44492 PyObject *resultobj = 0;
44493 wxMenu *arg1 = (wxMenu *) 0 ;
44494 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44495 void *argp1 = 0 ;
44496 int res1 = 0 ;
44497 void *argp2 = 0 ;
44498 int res2 = 0 ;
44499 PyObject * obj0 = 0 ;
44500 PyObject * obj1 = 0 ;
44501 char * kwnames[] = {
44502 (char *) "self",(char *) "source", NULL
44503 };
44504
44505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44507 if (!SWIG_IsOK(res1)) {
44508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44509 }
44510 arg1 = reinterpret_cast< wxMenu * >(argp1);
44511 if (obj1) {
44512 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44513 if (!SWIG_IsOK(res2)) {
44514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44515 }
44516 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44517 }
44518 {
44519 PyThreadState* __tstate = wxPyBeginAllowThreads();
44520 (arg1)->UpdateUI(arg2);
44521 wxPyEndAllowThreads(__tstate);
44522 if (PyErr_Occurred()) SWIG_fail;
44523 }
44524 resultobj = SWIG_Py_Void();
44525 return resultobj;
44526 fail:
44527 return NULL;
44528 }
44529
44530
44531 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44532 PyObject *resultobj = 0;
44533 wxMenu *arg1 = (wxMenu *) 0 ;
44534 wxMenuBar *result = 0 ;
44535 void *argp1 = 0 ;
44536 int res1 = 0 ;
44537 PyObject *swig_obj[1] ;
44538
44539 if (!args) SWIG_fail;
44540 swig_obj[0] = args;
44541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44542 if (!SWIG_IsOK(res1)) {
44543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44544 }
44545 arg1 = reinterpret_cast< wxMenu * >(argp1);
44546 {
44547 PyThreadState* __tstate = wxPyBeginAllowThreads();
44548 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44549 wxPyEndAllowThreads(__tstate);
44550 if (PyErr_Occurred()) SWIG_fail;
44551 }
44552 {
44553 resultobj = wxPyMake_wxObject(result, (bool)0);
44554 }
44555 return resultobj;
44556 fail:
44557 return NULL;
44558 }
44559
44560
44561 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44562 PyObject *resultobj = 0;
44563 wxMenu *arg1 = (wxMenu *) 0 ;
44564 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44565 void *argp1 = 0 ;
44566 int res1 = 0 ;
44567 void *argp2 = 0 ;
44568 int res2 = 0 ;
44569 PyObject * obj0 = 0 ;
44570 PyObject * obj1 = 0 ;
44571 char * kwnames[] = {
44572 (char *) "self",(char *) "menubar", NULL
44573 };
44574
44575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44577 if (!SWIG_IsOK(res1)) {
44578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44579 }
44580 arg1 = reinterpret_cast< wxMenu * >(argp1);
44581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44582 if (!SWIG_IsOK(res2)) {
44583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44584 }
44585 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44586 {
44587 PyThreadState* __tstate = wxPyBeginAllowThreads();
44588 (arg1)->Attach(arg2);
44589 wxPyEndAllowThreads(__tstate);
44590 if (PyErr_Occurred()) SWIG_fail;
44591 }
44592 resultobj = SWIG_Py_Void();
44593 return resultobj;
44594 fail:
44595 return NULL;
44596 }
44597
44598
44599 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44600 PyObject *resultobj = 0;
44601 wxMenu *arg1 = (wxMenu *) 0 ;
44602 void *argp1 = 0 ;
44603 int res1 = 0 ;
44604 PyObject *swig_obj[1] ;
44605
44606 if (!args) SWIG_fail;
44607 swig_obj[0] = args;
44608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44609 if (!SWIG_IsOK(res1)) {
44610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44611 }
44612 arg1 = reinterpret_cast< wxMenu * >(argp1);
44613 {
44614 PyThreadState* __tstate = wxPyBeginAllowThreads();
44615 (arg1)->Detach();
44616 wxPyEndAllowThreads(__tstate);
44617 if (PyErr_Occurred()) SWIG_fail;
44618 }
44619 resultobj = SWIG_Py_Void();
44620 return resultobj;
44621 fail:
44622 return NULL;
44623 }
44624
44625
44626 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44627 PyObject *resultobj = 0;
44628 wxMenu *arg1 = (wxMenu *) 0 ;
44629 bool result;
44630 void *argp1 = 0 ;
44631 int res1 = 0 ;
44632 PyObject *swig_obj[1] ;
44633
44634 if (!args) SWIG_fail;
44635 swig_obj[0] = args;
44636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44637 if (!SWIG_IsOK(res1)) {
44638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44639 }
44640 arg1 = reinterpret_cast< wxMenu * >(argp1);
44641 {
44642 PyThreadState* __tstate = wxPyBeginAllowThreads();
44643 result = (bool)((wxMenu const *)arg1)->IsAttached();
44644 wxPyEndAllowThreads(__tstate);
44645 if (PyErr_Occurred()) SWIG_fail;
44646 }
44647 {
44648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44649 }
44650 return resultobj;
44651 fail:
44652 return NULL;
44653 }
44654
44655
44656 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44657 PyObject *resultobj = 0;
44658 wxMenu *arg1 = (wxMenu *) 0 ;
44659 wxMenu *arg2 = (wxMenu *) 0 ;
44660 void *argp1 = 0 ;
44661 int res1 = 0 ;
44662 void *argp2 = 0 ;
44663 int res2 = 0 ;
44664 PyObject * obj0 = 0 ;
44665 PyObject * obj1 = 0 ;
44666 char * kwnames[] = {
44667 (char *) "self",(char *) "parent", NULL
44668 };
44669
44670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44672 if (!SWIG_IsOK(res1)) {
44673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44674 }
44675 arg1 = reinterpret_cast< wxMenu * >(argp1);
44676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44677 if (!SWIG_IsOK(res2)) {
44678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44679 }
44680 arg2 = reinterpret_cast< wxMenu * >(argp2);
44681 {
44682 PyThreadState* __tstate = wxPyBeginAllowThreads();
44683 (arg1)->SetParent(arg2);
44684 wxPyEndAllowThreads(__tstate);
44685 if (PyErr_Occurred()) SWIG_fail;
44686 }
44687 resultobj = SWIG_Py_Void();
44688 return resultobj;
44689 fail:
44690 return NULL;
44691 }
44692
44693
44694 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44695 PyObject *resultobj = 0;
44696 wxMenu *arg1 = (wxMenu *) 0 ;
44697 wxMenu *result = 0 ;
44698 void *argp1 = 0 ;
44699 int res1 = 0 ;
44700 PyObject *swig_obj[1] ;
44701
44702 if (!args) SWIG_fail;
44703 swig_obj[0] = args;
44704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44705 if (!SWIG_IsOK(res1)) {
44706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44707 }
44708 arg1 = reinterpret_cast< wxMenu * >(argp1);
44709 {
44710 PyThreadState* __tstate = wxPyBeginAllowThreads();
44711 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44712 wxPyEndAllowThreads(__tstate);
44713 if (PyErr_Occurred()) SWIG_fail;
44714 }
44715 {
44716 resultobj = wxPyMake_wxObject(result, 0);
44717 }
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44725 PyObject *obj;
44726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44727 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44728 return SWIG_Py_Void();
44729 }
44730
44731 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44732 return SWIG_Python_InitShadowInstance(args);
44733 }
44734
44735 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44736 PyObject *resultobj = 0;
44737 long arg1 = (long) 0 ;
44738 wxMenuBar *result = 0 ;
44739 long val1 ;
44740 int ecode1 = 0 ;
44741 PyObject * obj0 = 0 ;
44742 char * kwnames[] = {
44743 (char *) "style", NULL
44744 };
44745
44746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44747 if (obj0) {
44748 ecode1 = SWIG_AsVal_long(obj0, &val1);
44749 if (!SWIG_IsOK(ecode1)) {
44750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44751 }
44752 arg1 = static_cast< long >(val1);
44753 }
44754 {
44755 if (!wxPyCheckForApp()) SWIG_fail;
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 result = (wxMenuBar *)new wxMenuBar(arg1);
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44762 return resultobj;
44763 fail:
44764 return NULL;
44765 }
44766
44767
44768 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44769 PyObject *resultobj = 0;
44770 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44771 wxMenu *arg2 = (wxMenu *) 0 ;
44772 wxString *arg3 = 0 ;
44773 bool result;
44774 void *argp1 = 0 ;
44775 int res1 = 0 ;
44776 void *argp2 = 0 ;
44777 int res2 = 0 ;
44778 bool temp3 = false ;
44779 PyObject * obj0 = 0 ;
44780 PyObject * obj1 = 0 ;
44781 PyObject * obj2 = 0 ;
44782 char * kwnames[] = {
44783 (char *) "self",(char *) "menu",(char *) "title", NULL
44784 };
44785
44786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44788 if (!SWIG_IsOK(res1)) {
44789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44790 }
44791 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44793 if (!SWIG_IsOK(res2)) {
44794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44795 }
44796 arg2 = reinterpret_cast< wxMenu * >(argp2);
44797 {
44798 arg3 = wxString_in_helper(obj2);
44799 if (arg3 == NULL) SWIG_fail;
44800 temp3 = true;
44801 }
44802 {
44803 PyThreadState* __tstate = wxPyBeginAllowThreads();
44804 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44805 wxPyEndAllowThreads(__tstate);
44806 if (PyErr_Occurred()) SWIG_fail;
44807 }
44808 {
44809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44810 }
44811 {
44812 if (temp3)
44813 delete arg3;
44814 }
44815 return resultobj;
44816 fail:
44817 {
44818 if (temp3)
44819 delete arg3;
44820 }
44821 return NULL;
44822 }
44823
44824
44825 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44826 PyObject *resultobj = 0;
44827 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44828 size_t arg2 ;
44829 wxMenu *arg3 = (wxMenu *) 0 ;
44830 wxString *arg4 = 0 ;
44831 bool result;
44832 void *argp1 = 0 ;
44833 int res1 = 0 ;
44834 size_t val2 ;
44835 int ecode2 = 0 ;
44836 void *argp3 = 0 ;
44837 int res3 = 0 ;
44838 bool temp4 = false ;
44839 PyObject * obj0 = 0 ;
44840 PyObject * obj1 = 0 ;
44841 PyObject * obj2 = 0 ;
44842 PyObject * obj3 = 0 ;
44843 char * kwnames[] = {
44844 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44845 };
44846
44847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44849 if (!SWIG_IsOK(res1)) {
44850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44851 }
44852 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44853 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44854 if (!SWIG_IsOK(ecode2)) {
44855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44856 }
44857 arg2 = static_cast< size_t >(val2);
44858 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44859 if (!SWIG_IsOK(res3)) {
44860 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44861 }
44862 arg3 = reinterpret_cast< wxMenu * >(argp3);
44863 {
44864 arg4 = wxString_in_helper(obj3);
44865 if (arg4 == NULL) SWIG_fail;
44866 temp4 = true;
44867 }
44868 {
44869 PyThreadState* __tstate = wxPyBeginAllowThreads();
44870 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44871 wxPyEndAllowThreads(__tstate);
44872 if (PyErr_Occurred()) SWIG_fail;
44873 }
44874 {
44875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44876 }
44877 {
44878 if (temp4)
44879 delete arg4;
44880 }
44881 return resultobj;
44882 fail:
44883 {
44884 if (temp4)
44885 delete arg4;
44886 }
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44892 PyObject *resultobj = 0;
44893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44894 size_t result;
44895 void *argp1 = 0 ;
44896 int res1 = 0 ;
44897 PyObject *swig_obj[1] ;
44898
44899 if (!args) SWIG_fail;
44900 swig_obj[0] = args;
44901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44902 if (!SWIG_IsOK(res1)) {
44903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44904 }
44905 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44906 {
44907 PyThreadState* __tstate = wxPyBeginAllowThreads();
44908 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44909 wxPyEndAllowThreads(__tstate);
44910 if (PyErr_Occurred()) SWIG_fail;
44911 }
44912 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44920 PyObject *resultobj = 0;
44921 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44922 size_t arg2 ;
44923 wxMenu *result = 0 ;
44924 void *argp1 = 0 ;
44925 int res1 = 0 ;
44926 size_t val2 ;
44927 int ecode2 = 0 ;
44928 PyObject * obj0 = 0 ;
44929 PyObject * obj1 = 0 ;
44930 char * kwnames[] = {
44931 (char *) "self",(char *) "pos", NULL
44932 };
44933
44934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44936 if (!SWIG_IsOK(res1)) {
44937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44938 }
44939 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44940 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44941 if (!SWIG_IsOK(ecode2)) {
44942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44943 }
44944 arg2 = static_cast< size_t >(val2);
44945 {
44946 PyThreadState* __tstate = wxPyBeginAllowThreads();
44947 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44948 wxPyEndAllowThreads(__tstate);
44949 if (PyErr_Occurred()) SWIG_fail;
44950 }
44951 {
44952 resultobj = wxPyMake_wxObject(result, 0);
44953 }
44954 return resultobj;
44955 fail:
44956 return NULL;
44957 }
44958
44959
44960 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44961 PyObject *resultobj = 0;
44962 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44963 size_t arg2 ;
44964 wxMenu *arg3 = (wxMenu *) 0 ;
44965 wxString *arg4 = 0 ;
44966 wxMenu *result = 0 ;
44967 void *argp1 = 0 ;
44968 int res1 = 0 ;
44969 size_t val2 ;
44970 int ecode2 = 0 ;
44971 void *argp3 = 0 ;
44972 int res3 = 0 ;
44973 bool temp4 = false ;
44974 PyObject * obj0 = 0 ;
44975 PyObject * obj1 = 0 ;
44976 PyObject * obj2 = 0 ;
44977 PyObject * obj3 = 0 ;
44978 char * kwnames[] = {
44979 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44980 };
44981
44982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44984 if (!SWIG_IsOK(res1)) {
44985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44986 }
44987 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44988 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44989 if (!SWIG_IsOK(ecode2)) {
44990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44991 }
44992 arg2 = static_cast< size_t >(val2);
44993 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44994 if (!SWIG_IsOK(res3)) {
44995 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44996 }
44997 arg3 = reinterpret_cast< wxMenu * >(argp3);
44998 {
44999 arg4 = wxString_in_helper(obj3);
45000 if (arg4 == NULL) SWIG_fail;
45001 temp4 = true;
45002 }
45003 {
45004 PyThreadState* __tstate = wxPyBeginAllowThreads();
45005 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45006 wxPyEndAllowThreads(__tstate);
45007 if (PyErr_Occurred()) SWIG_fail;
45008 }
45009 {
45010 resultobj = wxPyMake_wxObject(result, 0);
45011 }
45012 {
45013 if (temp4)
45014 delete arg4;
45015 }
45016 return resultobj;
45017 fail:
45018 {
45019 if (temp4)
45020 delete arg4;
45021 }
45022 return NULL;
45023 }
45024
45025
45026 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45027 PyObject *resultobj = 0;
45028 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45029 size_t arg2 ;
45030 wxMenu *result = 0 ;
45031 void *argp1 = 0 ;
45032 int res1 = 0 ;
45033 size_t val2 ;
45034 int ecode2 = 0 ;
45035 PyObject * obj0 = 0 ;
45036 PyObject * obj1 = 0 ;
45037 char * kwnames[] = {
45038 (char *) "self",(char *) "pos", NULL
45039 };
45040
45041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45043 if (!SWIG_IsOK(res1)) {
45044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45045 }
45046 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45047 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45048 if (!SWIG_IsOK(ecode2)) {
45049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45050 }
45051 arg2 = static_cast< size_t >(val2);
45052 {
45053 PyThreadState* __tstate = wxPyBeginAllowThreads();
45054 result = (wxMenu *)(arg1)->Remove(arg2);
45055 wxPyEndAllowThreads(__tstate);
45056 if (PyErr_Occurred()) SWIG_fail;
45057 }
45058 {
45059 resultobj = wxPyMake_wxObject(result, 0);
45060 }
45061 return resultobj;
45062 fail:
45063 return NULL;
45064 }
45065
45066
45067 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45068 PyObject *resultobj = 0;
45069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45070 size_t arg2 ;
45071 bool arg3 ;
45072 void *argp1 = 0 ;
45073 int res1 = 0 ;
45074 size_t val2 ;
45075 int ecode2 = 0 ;
45076 bool val3 ;
45077 int ecode3 = 0 ;
45078 PyObject * obj0 = 0 ;
45079 PyObject * obj1 = 0 ;
45080 PyObject * obj2 = 0 ;
45081 char * kwnames[] = {
45082 (char *) "self",(char *) "pos",(char *) "enable", NULL
45083 };
45084
45085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45087 if (!SWIG_IsOK(res1)) {
45088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45089 }
45090 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45091 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45092 if (!SWIG_IsOK(ecode2)) {
45093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45094 }
45095 arg2 = static_cast< size_t >(val2);
45096 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45097 if (!SWIG_IsOK(ecode3)) {
45098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45099 }
45100 arg3 = static_cast< bool >(val3);
45101 {
45102 PyThreadState* __tstate = wxPyBeginAllowThreads();
45103 (arg1)->EnableTop(arg2,arg3);
45104 wxPyEndAllowThreads(__tstate);
45105 if (PyErr_Occurred()) SWIG_fail;
45106 }
45107 resultobj = SWIG_Py_Void();
45108 return resultobj;
45109 fail:
45110 return NULL;
45111 }
45112
45113
45114 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45115 PyObject *resultobj = 0;
45116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45117 size_t arg2 ;
45118 bool result;
45119 void *argp1 = 0 ;
45120 int res1 = 0 ;
45121 size_t val2 ;
45122 int ecode2 = 0 ;
45123 PyObject * obj0 = 0 ;
45124 PyObject * obj1 = 0 ;
45125 char * kwnames[] = {
45126 (char *) "self",(char *) "pos", NULL
45127 };
45128
45129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45131 if (!SWIG_IsOK(res1)) {
45132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45133 }
45134 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45135 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45136 if (!SWIG_IsOK(ecode2)) {
45137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45138 }
45139 arg2 = static_cast< size_t >(val2);
45140 {
45141 PyThreadState* __tstate = wxPyBeginAllowThreads();
45142 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45143 wxPyEndAllowThreads(__tstate);
45144 if (PyErr_Occurred()) SWIG_fail;
45145 }
45146 {
45147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45148 }
45149 return resultobj;
45150 fail:
45151 return NULL;
45152 }
45153
45154
45155 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45156 PyObject *resultobj = 0;
45157 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45158 size_t arg2 ;
45159 wxString *arg3 = 0 ;
45160 void *argp1 = 0 ;
45161 int res1 = 0 ;
45162 size_t val2 ;
45163 int ecode2 = 0 ;
45164 bool temp3 = false ;
45165 PyObject * obj0 = 0 ;
45166 PyObject * obj1 = 0 ;
45167 PyObject * obj2 = 0 ;
45168 char * kwnames[] = {
45169 (char *) "self",(char *) "pos",(char *) "label", NULL
45170 };
45171
45172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45174 if (!SWIG_IsOK(res1)) {
45175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45176 }
45177 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45178 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45179 if (!SWIG_IsOK(ecode2)) {
45180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45181 }
45182 arg2 = static_cast< size_t >(val2);
45183 {
45184 arg3 = wxString_in_helper(obj2);
45185 if (arg3 == NULL) SWIG_fail;
45186 temp3 = true;
45187 }
45188 {
45189 PyThreadState* __tstate = wxPyBeginAllowThreads();
45190 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45191 wxPyEndAllowThreads(__tstate);
45192 if (PyErr_Occurred()) SWIG_fail;
45193 }
45194 resultobj = SWIG_Py_Void();
45195 {
45196 if (temp3)
45197 delete arg3;
45198 }
45199 return resultobj;
45200 fail:
45201 {
45202 if (temp3)
45203 delete arg3;
45204 }
45205 return NULL;
45206 }
45207
45208
45209 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45210 PyObject *resultobj = 0;
45211 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45212 size_t arg2 ;
45213 wxString result;
45214 void *argp1 = 0 ;
45215 int res1 = 0 ;
45216 size_t val2 ;
45217 int ecode2 = 0 ;
45218 PyObject * obj0 = 0 ;
45219 PyObject * obj1 = 0 ;
45220 char * kwnames[] = {
45221 (char *) "self",(char *) "pos", NULL
45222 };
45223
45224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45226 if (!SWIG_IsOK(res1)) {
45227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45228 }
45229 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45230 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45231 if (!SWIG_IsOK(ecode2)) {
45232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45233 }
45234 arg2 = static_cast< size_t >(val2);
45235 {
45236 PyThreadState* __tstate = wxPyBeginAllowThreads();
45237 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45238 wxPyEndAllowThreads(__tstate);
45239 if (PyErr_Occurred()) SWIG_fail;
45240 }
45241 {
45242 #if wxUSE_UNICODE
45243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45244 #else
45245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45246 #endif
45247 }
45248 return resultobj;
45249 fail:
45250 return NULL;
45251 }
45252
45253
45254 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45255 PyObject *resultobj = 0;
45256 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45257 wxString *arg2 = 0 ;
45258 wxString *arg3 = 0 ;
45259 int result;
45260 void *argp1 = 0 ;
45261 int res1 = 0 ;
45262 bool temp2 = false ;
45263 bool temp3 = false ;
45264 PyObject * obj0 = 0 ;
45265 PyObject * obj1 = 0 ;
45266 PyObject * obj2 = 0 ;
45267 char * kwnames[] = {
45268 (char *) "self",(char *) "menu",(char *) "item", NULL
45269 };
45270
45271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45273 if (!SWIG_IsOK(res1)) {
45274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45275 }
45276 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45277 {
45278 arg2 = wxString_in_helper(obj1);
45279 if (arg2 == NULL) SWIG_fail;
45280 temp2 = true;
45281 }
45282 {
45283 arg3 = wxString_in_helper(obj2);
45284 if (arg3 == NULL) SWIG_fail;
45285 temp3 = true;
45286 }
45287 {
45288 PyThreadState* __tstate = wxPyBeginAllowThreads();
45289 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45290 wxPyEndAllowThreads(__tstate);
45291 if (PyErr_Occurred()) SWIG_fail;
45292 }
45293 resultobj = SWIG_From_int(static_cast< int >(result));
45294 {
45295 if (temp2)
45296 delete arg2;
45297 }
45298 {
45299 if (temp3)
45300 delete arg3;
45301 }
45302 return resultobj;
45303 fail:
45304 {
45305 if (temp2)
45306 delete arg2;
45307 }
45308 {
45309 if (temp3)
45310 delete arg3;
45311 }
45312 return NULL;
45313 }
45314
45315
45316 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45317 PyObject *resultobj = 0;
45318 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45319 int arg2 ;
45320 wxMenuItem *result = 0 ;
45321 void *argp1 = 0 ;
45322 int res1 = 0 ;
45323 int val2 ;
45324 int ecode2 = 0 ;
45325 PyObject * obj0 = 0 ;
45326 PyObject * obj1 = 0 ;
45327 char * kwnames[] = {
45328 (char *) "self",(char *) "id", NULL
45329 };
45330
45331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45333 if (!SWIG_IsOK(res1)) {
45334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45335 }
45336 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45337 ecode2 = SWIG_AsVal_int(obj1, &val2);
45338 if (!SWIG_IsOK(ecode2)) {
45339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45340 }
45341 arg2 = static_cast< int >(val2);
45342 {
45343 PyThreadState* __tstate = wxPyBeginAllowThreads();
45344 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45345 wxPyEndAllowThreads(__tstate);
45346 if (PyErr_Occurred()) SWIG_fail;
45347 }
45348 {
45349 resultobj = wxPyMake_wxObject(result, (bool)0);
45350 }
45351 return resultobj;
45352 fail:
45353 return NULL;
45354 }
45355
45356
45357 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45358 PyObject *resultobj = 0;
45359 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45360 wxString *arg2 = 0 ;
45361 int result;
45362 void *argp1 = 0 ;
45363 int res1 = 0 ;
45364 bool temp2 = false ;
45365 PyObject * obj0 = 0 ;
45366 PyObject * obj1 = 0 ;
45367 char * kwnames[] = {
45368 (char *) "self",(char *) "title", NULL
45369 };
45370
45371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45373 if (!SWIG_IsOK(res1)) {
45374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45375 }
45376 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45377 {
45378 arg2 = wxString_in_helper(obj1);
45379 if (arg2 == NULL) SWIG_fail;
45380 temp2 = true;
45381 }
45382 {
45383 PyThreadState* __tstate = wxPyBeginAllowThreads();
45384 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45385 wxPyEndAllowThreads(__tstate);
45386 if (PyErr_Occurred()) SWIG_fail;
45387 }
45388 resultobj = SWIG_From_int(static_cast< int >(result));
45389 {
45390 if (temp2)
45391 delete arg2;
45392 }
45393 return resultobj;
45394 fail:
45395 {
45396 if (temp2)
45397 delete arg2;
45398 }
45399 return NULL;
45400 }
45401
45402
45403 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45404 PyObject *resultobj = 0;
45405 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45406 int arg2 ;
45407 bool arg3 ;
45408 void *argp1 = 0 ;
45409 int res1 = 0 ;
45410 int val2 ;
45411 int ecode2 = 0 ;
45412 bool val3 ;
45413 int ecode3 = 0 ;
45414 PyObject * obj0 = 0 ;
45415 PyObject * obj1 = 0 ;
45416 PyObject * obj2 = 0 ;
45417 char * kwnames[] = {
45418 (char *) "self",(char *) "id",(char *) "enable", NULL
45419 };
45420
45421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45423 if (!SWIG_IsOK(res1)) {
45424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45425 }
45426 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45427 ecode2 = SWIG_AsVal_int(obj1, &val2);
45428 if (!SWIG_IsOK(ecode2)) {
45429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45430 }
45431 arg2 = static_cast< int >(val2);
45432 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45433 if (!SWIG_IsOK(ecode3)) {
45434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45435 }
45436 arg3 = static_cast< bool >(val3);
45437 {
45438 PyThreadState* __tstate = wxPyBeginAllowThreads();
45439 (arg1)->Enable(arg2,arg3);
45440 wxPyEndAllowThreads(__tstate);
45441 if (PyErr_Occurred()) SWIG_fail;
45442 }
45443 resultobj = SWIG_Py_Void();
45444 return resultobj;
45445 fail:
45446 return NULL;
45447 }
45448
45449
45450 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45451 PyObject *resultobj = 0;
45452 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45453 int arg2 ;
45454 bool arg3 ;
45455 void *argp1 = 0 ;
45456 int res1 = 0 ;
45457 int val2 ;
45458 int ecode2 = 0 ;
45459 bool val3 ;
45460 int ecode3 = 0 ;
45461 PyObject * obj0 = 0 ;
45462 PyObject * obj1 = 0 ;
45463 PyObject * obj2 = 0 ;
45464 char * kwnames[] = {
45465 (char *) "self",(char *) "id",(char *) "check", NULL
45466 };
45467
45468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45470 if (!SWIG_IsOK(res1)) {
45471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45472 }
45473 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45474 ecode2 = SWIG_AsVal_int(obj1, &val2);
45475 if (!SWIG_IsOK(ecode2)) {
45476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45477 }
45478 arg2 = static_cast< int >(val2);
45479 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45480 if (!SWIG_IsOK(ecode3)) {
45481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45482 }
45483 arg3 = static_cast< bool >(val3);
45484 {
45485 PyThreadState* __tstate = wxPyBeginAllowThreads();
45486 (arg1)->Check(arg2,arg3);
45487 wxPyEndAllowThreads(__tstate);
45488 if (PyErr_Occurred()) SWIG_fail;
45489 }
45490 resultobj = SWIG_Py_Void();
45491 return resultobj;
45492 fail:
45493 return NULL;
45494 }
45495
45496
45497 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45498 PyObject *resultobj = 0;
45499 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45500 int arg2 ;
45501 bool result;
45502 void *argp1 = 0 ;
45503 int res1 = 0 ;
45504 int val2 ;
45505 int ecode2 = 0 ;
45506 PyObject * obj0 = 0 ;
45507 PyObject * obj1 = 0 ;
45508 char * kwnames[] = {
45509 (char *) "self",(char *) "id", NULL
45510 };
45511
45512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45516 }
45517 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45518 ecode2 = SWIG_AsVal_int(obj1, &val2);
45519 if (!SWIG_IsOK(ecode2)) {
45520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45521 }
45522 arg2 = static_cast< int >(val2);
45523 {
45524 PyThreadState* __tstate = wxPyBeginAllowThreads();
45525 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45526 wxPyEndAllowThreads(__tstate);
45527 if (PyErr_Occurred()) SWIG_fail;
45528 }
45529 {
45530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45531 }
45532 return resultobj;
45533 fail:
45534 return NULL;
45535 }
45536
45537
45538 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45539 PyObject *resultobj = 0;
45540 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45541 int arg2 ;
45542 bool result;
45543 void *argp1 = 0 ;
45544 int res1 = 0 ;
45545 int val2 ;
45546 int ecode2 = 0 ;
45547 PyObject * obj0 = 0 ;
45548 PyObject * obj1 = 0 ;
45549 char * kwnames[] = {
45550 (char *) "self",(char *) "id", NULL
45551 };
45552
45553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45555 if (!SWIG_IsOK(res1)) {
45556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45557 }
45558 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45559 ecode2 = SWIG_AsVal_int(obj1, &val2);
45560 if (!SWIG_IsOK(ecode2)) {
45561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45562 }
45563 arg2 = static_cast< int >(val2);
45564 {
45565 PyThreadState* __tstate = wxPyBeginAllowThreads();
45566 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45567 wxPyEndAllowThreads(__tstate);
45568 if (PyErr_Occurred()) SWIG_fail;
45569 }
45570 {
45571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45572 }
45573 return resultobj;
45574 fail:
45575 return NULL;
45576 }
45577
45578
45579 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45580 PyObject *resultobj = 0;
45581 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45582 int arg2 ;
45583 wxString *arg3 = 0 ;
45584 void *argp1 = 0 ;
45585 int res1 = 0 ;
45586 int val2 ;
45587 int ecode2 = 0 ;
45588 bool temp3 = false ;
45589 PyObject * obj0 = 0 ;
45590 PyObject * obj1 = 0 ;
45591 PyObject * obj2 = 0 ;
45592 char * kwnames[] = {
45593 (char *) "self",(char *) "id",(char *) "label", NULL
45594 };
45595
45596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45598 if (!SWIG_IsOK(res1)) {
45599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45600 }
45601 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45602 ecode2 = SWIG_AsVal_int(obj1, &val2);
45603 if (!SWIG_IsOK(ecode2)) {
45604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45605 }
45606 arg2 = static_cast< int >(val2);
45607 {
45608 arg3 = wxString_in_helper(obj2);
45609 if (arg3 == NULL) SWIG_fail;
45610 temp3 = true;
45611 }
45612 {
45613 PyThreadState* __tstate = wxPyBeginAllowThreads();
45614 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45615 wxPyEndAllowThreads(__tstate);
45616 if (PyErr_Occurred()) SWIG_fail;
45617 }
45618 resultobj = SWIG_Py_Void();
45619 {
45620 if (temp3)
45621 delete arg3;
45622 }
45623 return resultobj;
45624 fail:
45625 {
45626 if (temp3)
45627 delete arg3;
45628 }
45629 return NULL;
45630 }
45631
45632
45633 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45634 PyObject *resultobj = 0;
45635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45636 int arg2 ;
45637 wxString result;
45638 void *argp1 = 0 ;
45639 int res1 = 0 ;
45640 int val2 ;
45641 int ecode2 = 0 ;
45642 PyObject * obj0 = 0 ;
45643 PyObject * obj1 = 0 ;
45644 char * kwnames[] = {
45645 (char *) "self",(char *) "id", NULL
45646 };
45647
45648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45650 if (!SWIG_IsOK(res1)) {
45651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45652 }
45653 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45654 ecode2 = SWIG_AsVal_int(obj1, &val2);
45655 if (!SWIG_IsOK(ecode2)) {
45656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45657 }
45658 arg2 = static_cast< int >(val2);
45659 {
45660 PyThreadState* __tstate = wxPyBeginAllowThreads();
45661 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45662 wxPyEndAllowThreads(__tstate);
45663 if (PyErr_Occurred()) SWIG_fail;
45664 }
45665 {
45666 #if wxUSE_UNICODE
45667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45668 #else
45669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45670 #endif
45671 }
45672 return resultobj;
45673 fail:
45674 return NULL;
45675 }
45676
45677
45678 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45679 PyObject *resultobj = 0;
45680 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45681 int arg2 ;
45682 wxString *arg3 = 0 ;
45683 void *argp1 = 0 ;
45684 int res1 = 0 ;
45685 int val2 ;
45686 int ecode2 = 0 ;
45687 bool temp3 = false ;
45688 PyObject * obj0 = 0 ;
45689 PyObject * obj1 = 0 ;
45690 PyObject * obj2 = 0 ;
45691 char * kwnames[] = {
45692 (char *) "self",(char *) "id",(char *) "helpString", NULL
45693 };
45694
45695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45697 if (!SWIG_IsOK(res1)) {
45698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45699 }
45700 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45701 ecode2 = SWIG_AsVal_int(obj1, &val2);
45702 if (!SWIG_IsOK(ecode2)) {
45703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45704 }
45705 arg2 = static_cast< int >(val2);
45706 {
45707 arg3 = wxString_in_helper(obj2);
45708 if (arg3 == NULL) SWIG_fail;
45709 temp3 = true;
45710 }
45711 {
45712 PyThreadState* __tstate = wxPyBeginAllowThreads();
45713 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45714 wxPyEndAllowThreads(__tstate);
45715 if (PyErr_Occurred()) SWIG_fail;
45716 }
45717 resultobj = SWIG_Py_Void();
45718 {
45719 if (temp3)
45720 delete arg3;
45721 }
45722 return resultobj;
45723 fail:
45724 {
45725 if (temp3)
45726 delete arg3;
45727 }
45728 return NULL;
45729 }
45730
45731
45732 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45733 PyObject *resultobj = 0;
45734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45735 int arg2 ;
45736 wxString result;
45737 void *argp1 = 0 ;
45738 int res1 = 0 ;
45739 int val2 ;
45740 int ecode2 = 0 ;
45741 PyObject * obj0 = 0 ;
45742 PyObject * obj1 = 0 ;
45743 char * kwnames[] = {
45744 (char *) "self",(char *) "id", NULL
45745 };
45746
45747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45749 if (!SWIG_IsOK(res1)) {
45750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45751 }
45752 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45753 ecode2 = SWIG_AsVal_int(obj1, &val2);
45754 if (!SWIG_IsOK(ecode2)) {
45755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45756 }
45757 arg2 = static_cast< int >(val2);
45758 {
45759 PyThreadState* __tstate = wxPyBeginAllowThreads();
45760 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45761 wxPyEndAllowThreads(__tstate);
45762 if (PyErr_Occurred()) SWIG_fail;
45763 }
45764 {
45765 #if wxUSE_UNICODE
45766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45767 #else
45768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45769 #endif
45770 }
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45778 PyObject *resultobj = 0;
45779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45780 wxFrame *result = 0 ;
45781 void *argp1 = 0 ;
45782 int res1 = 0 ;
45783 PyObject *swig_obj[1] ;
45784
45785 if (!args) SWIG_fail;
45786 swig_obj[0] = args;
45787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45788 if (!SWIG_IsOK(res1)) {
45789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45790 }
45791 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45792 {
45793 PyThreadState* __tstate = wxPyBeginAllowThreads();
45794 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45795 wxPyEndAllowThreads(__tstate);
45796 if (PyErr_Occurred()) SWIG_fail;
45797 }
45798 {
45799 resultobj = wxPyMake_wxObject(result, (bool)0);
45800 }
45801 return resultobj;
45802 fail:
45803 return NULL;
45804 }
45805
45806
45807 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45808 PyObject *resultobj = 0;
45809 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45810 bool result;
45811 void *argp1 = 0 ;
45812 int res1 = 0 ;
45813 PyObject *swig_obj[1] ;
45814
45815 if (!args) SWIG_fail;
45816 swig_obj[0] = args;
45817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45818 if (!SWIG_IsOK(res1)) {
45819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45820 }
45821 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45822 {
45823 PyThreadState* __tstate = wxPyBeginAllowThreads();
45824 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45825 wxPyEndAllowThreads(__tstate);
45826 if (PyErr_Occurred()) SWIG_fail;
45827 }
45828 {
45829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45830 }
45831 return resultobj;
45832 fail:
45833 return NULL;
45834 }
45835
45836
45837 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45838 PyObject *resultobj = 0;
45839 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45840 wxFrame *arg2 = (wxFrame *) 0 ;
45841 void *argp1 = 0 ;
45842 int res1 = 0 ;
45843 void *argp2 = 0 ;
45844 int res2 = 0 ;
45845 PyObject * obj0 = 0 ;
45846 PyObject * obj1 = 0 ;
45847 char * kwnames[] = {
45848 (char *) "self",(char *) "frame", NULL
45849 };
45850
45851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45853 if (!SWIG_IsOK(res1)) {
45854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45855 }
45856 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45858 if (!SWIG_IsOK(res2)) {
45859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45860 }
45861 arg2 = reinterpret_cast< wxFrame * >(argp2);
45862 {
45863 PyThreadState* __tstate = wxPyBeginAllowThreads();
45864 (arg1)->Attach(arg2);
45865 wxPyEndAllowThreads(__tstate);
45866 if (PyErr_Occurred()) SWIG_fail;
45867 }
45868 resultobj = SWIG_Py_Void();
45869 return resultobj;
45870 fail:
45871 return NULL;
45872 }
45873
45874
45875 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45876 PyObject *resultobj = 0;
45877 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45878 void *argp1 = 0 ;
45879 int res1 = 0 ;
45880 PyObject *swig_obj[1] ;
45881
45882 if (!args) SWIG_fail;
45883 swig_obj[0] = args;
45884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45885 if (!SWIG_IsOK(res1)) {
45886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45887 }
45888 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45889 {
45890 PyThreadState* __tstate = wxPyBeginAllowThreads();
45891 (arg1)->Detach();
45892 wxPyEndAllowThreads(__tstate);
45893 if (PyErr_Occurred()) SWIG_fail;
45894 }
45895 resultobj = SWIG_Py_Void();
45896 return resultobj;
45897 fail:
45898 return NULL;
45899 }
45900
45901
45902 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45903 PyObject *resultobj = 0;
45904 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45905 void *argp1 = 0 ;
45906 int res1 = 0 ;
45907 PyObject *swig_obj[1] ;
45908
45909 if (!args) SWIG_fail;
45910 swig_obj[0] = args;
45911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45912 if (!SWIG_IsOK(res1)) {
45913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45914 }
45915 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45916 {
45917 PyThreadState* __tstate = wxPyBeginAllowThreads();
45918 (arg1)->UpdateMenus();
45919 wxPyEndAllowThreads(__tstate);
45920 if (PyErr_Occurred()) SWIG_fail;
45921 }
45922 resultobj = SWIG_Py_Void();
45923 return resultobj;
45924 fail:
45925 return NULL;
45926 }
45927
45928
45929 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45930 PyObject *resultobj = 0;
45931 bool arg1 ;
45932 bool val1 ;
45933 int ecode1 = 0 ;
45934 PyObject * obj0 = 0 ;
45935 char * kwnames[] = {
45936 (char *) "enable", NULL
45937 };
45938
45939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45940 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45941 if (!SWIG_IsOK(ecode1)) {
45942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45943 }
45944 arg1 = static_cast< bool >(val1);
45945 {
45946 PyThreadState* __tstate = wxPyBeginAllowThreads();
45947 wxMenuBar::SetAutoWindowMenu(arg1);
45948 wxPyEndAllowThreads(__tstate);
45949 if (PyErr_Occurred()) SWIG_fail;
45950 }
45951 resultobj = SWIG_Py_Void();
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45959 PyObject *resultobj = 0;
45960 bool result;
45961
45962 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45963 {
45964 PyThreadState* __tstate = wxPyBeginAllowThreads();
45965 result = (bool)wxMenuBar::GetAutoWindowMenu();
45966 wxPyEndAllowThreads(__tstate);
45967 if (PyErr_Occurred()) SWIG_fail;
45968 }
45969 {
45970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45971 }
45972 return resultobj;
45973 fail:
45974 return NULL;
45975 }
45976
45977
45978 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45979 PyObject *obj;
45980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45981 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45982 return SWIG_Py_Void();
45983 }
45984
45985 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45986 return SWIG_Python_InitShadowInstance(args);
45987 }
45988
45989 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45990 PyObject *resultobj = 0;
45991 wxMenu *arg1 = (wxMenu *) NULL ;
45992 int arg2 = (int) wxID_SEPARATOR ;
45993 wxString const &arg3_defvalue = wxPyEmptyString ;
45994 wxString *arg3 = (wxString *) &arg3_defvalue ;
45995 wxString const &arg4_defvalue = wxPyEmptyString ;
45996 wxString *arg4 = (wxString *) &arg4_defvalue ;
45997 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45998 wxMenu *arg6 = (wxMenu *) NULL ;
45999 wxMenuItem *result = 0 ;
46000 void *argp1 = 0 ;
46001 int res1 = 0 ;
46002 int val2 ;
46003 int ecode2 = 0 ;
46004 bool temp3 = false ;
46005 bool temp4 = false ;
46006 int val5 ;
46007 int ecode5 = 0 ;
46008 void *argp6 = 0 ;
46009 int res6 = 0 ;
46010 PyObject * obj0 = 0 ;
46011 PyObject * obj1 = 0 ;
46012 PyObject * obj2 = 0 ;
46013 PyObject * obj3 = 0 ;
46014 PyObject * obj4 = 0 ;
46015 PyObject * obj5 = 0 ;
46016 char * kwnames[] = {
46017 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46018 };
46019
46020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46021 if (obj0) {
46022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46023 if (!SWIG_IsOK(res1)) {
46024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46025 }
46026 arg1 = reinterpret_cast< wxMenu * >(argp1);
46027 }
46028 if (obj1) {
46029 ecode2 = SWIG_AsVal_int(obj1, &val2);
46030 if (!SWIG_IsOK(ecode2)) {
46031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46032 }
46033 arg2 = static_cast< int >(val2);
46034 }
46035 if (obj2) {
46036 {
46037 arg3 = wxString_in_helper(obj2);
46038 if (arg3 == NULL) SWIG_fail;
46039 temp3 = true;
46040 }
46041 }
46042 if (obj3) {
46043 {
46044 arg4 = wxString_in_helper(obj3);
46045 if (arg4 == NULL) SWIG_fail;
46046 temp4 = true;
46047 }
46048 }
46049 if (obj4) {
46050 ecode5 = SWIG_AsVal_int(obj4, &val5);
46051 if (!SWIG_IsOK(ecode5)) {
46052 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46053 }
46054 arg5 = static_cast< wxItemKind >(val5);
46055 }
46056 if (obj5) {
46057 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46058 if (!SWIG_IsOK(res6)) {
46059 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46060 }
46061 arg6 = reinterpret_cast< wxMenu * >(argp6);
46062 }
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46070 {
46071 if (temp3)
46072 delete arg3;
46073 }
46074 {
46075 if (temp4)
46076 delete arg4;
46077 }
46078 return resultobj;
46079 fail:
46080 {
46081 if (temp3)
46082 delete arg3;
46083 }
46084 {
46085 if (temp4)
46086 delete arg4;
46087 }
46088 return NULL;
46089 }
46090
46091
46092 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46093 PyObject *resultobj = 0;
46094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46095 void *argp1 = 0 ;
46096 int res1 = 0 ;
46097 PyObject *swig_obj[1] ;
46098
46099 if (!args) SWIG_fail;
46100 swig_obj[0] = args;
46101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46102 if (!SWIG_IsOK(res1)) {
46103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46104 }
46105 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46106 {
46107 PyThreadState* __tstate = wxPyBeginAllowThreads();
46108 delete arg1;
46109
46110 wxPyEndAllowThreads(__tstate);
46111 if (PyErr_Occurred()) SWIG_fail;
46112 }
46113 resultobj = SWIG_Py_Void();
46114 return resultobj;
46115 fail:
46116 return NULL;
46117 }
46118
46119
46120 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46121 PyObject *resultobj = 0;
46122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46123 wxMenu *result = 0 ;
46124 void *argp1 = 0 ;
46125 int res1 = 0 ;
46126 PyObject *swig_obj[1] ;
46127
46128 if (!args) SWIG_fail;
46129 swig_obj[0] = args;
46130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46131 if (!SWIG_IsOK(res1)) {
46132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46133 }
46134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46135 {
46136 PyThreadState* __tstate = wxPyBeginAllowThreads();
46137 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46138 wxPyEndAllowThreads(__tstate);
46139 if (PyErr_Occurred()) SWIG_fail;
46140 }
46141 {
46142 resultobj = wxPyMake_wxObject(result, 0);
46143 }
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46153 wxMenu *arg2 = (wxMenu *) 0 ;
46154 void *argp1 = 0 ;
46155 int res1 = 0 ;
46156 void *argp2 = 0 ;
46157 int res2 = 0 ;
46158 PyObject * obj0 = 0 ;
46159 PyObject * obj1 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "menu", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46168 }
46169 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46171 if (!SWIG_IsOK(res2)) {
46172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46173 }
46174 arg2 = reinterpret_cast< wxMenu * >(argp2);
46175 {
46176 PyThreadState* __tstate = wxPyBeginAllowThreads();
46177 (arg1)->SetMenu(arg2);
46178 wxPyEndAllowThreads(__tstate);
46179 if (PyErr_Occurred()) SWIG_fail;
46180 }
46181 resultobj = SWIG_Py_Void();
46182 return resultobj;
46183 fail:
46184 return NULL;
46185 }
46186
46187
46188 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46189 PyObject *resultobj = 0;
46190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46191 int arg2 ;
46192 void *argp1 = 0 ;
46193 int res1 = 0 ;
46194 int val2 ;
46195 int ecode2 = 0 ;
46196 PyObject * obj0 = 0 ;
46197 PyObject * obj1 = 0 ;
46198 char * kwnames[] = {
46199 (char *) "self",(char *) "id", NULL
46200 };
46201
46202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46204 if (!SWIG_IsOK(res1)) {
46205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46206 }
46207 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46208 ecode2 = SWIG_AsVal_int(obj1, &val2);
46209 if (!SWIG_IsOK(ecode2)) {
46210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46211 }
46212 arg2 = static_cast< int >(val2);
46213 {
46214 PyThreadState* __tstate = wxPyBeginAllowThreads();
46215 (arg1)->SetId(arg2);
46216 wxPyEndAllowThreads(__tstate);
46217 if (PyErr_Occurred()) SWIG_fail;
46218 }
46219 resultobj = SWIG_Py_Void();
46220 return resultobj;
46221 fail:
46222 return NULL;
46223 }
46224
46225
46226 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46227 PyObject *resultobj = 0;
46228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46229 int result;
46230 void *argp1 = 0 ;
46231 int res1 = 0 ;
46232 PyObject *swig_obj[1] ;
46233
46234 if (!args) SWIG_fail;
46235 swig_obj[0] = args;
46236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46237 if (!SWIG_IsOK(res1)) {
46238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46239 }
46240 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46241 {
46242 PyThreadState* __tstate = wxPyBeginAllowThreads();
46243 result = (int)((wxMenuItem const *)arg1)->GetId();
46244 wxPyEndAllowThreads(__tstate);
46245 if (PyErr_Occurred()) SWIG_fail;
46246 }
46247 resultobj = SWIG_From_int(static_cast< int >(result));
46248 return resultobj;
46249 fail:
46250 return NULL;
46251 }
46252
46253
46254 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46255 PyObject *resultobj = 0;
46256 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46257 bool result;
46258 void *argp1 = 0 ;
46259 int res1 = 0 ;
46260 PyObject *swig_obj[1] ;
46261
46262 if (!args) SWIG_fail;
46263 swig_obj[0] = args;
46264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46265 if (!SWIG_IsOK(res1)) {
46266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46267 }
46268 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46269 {
46270 PyThreadState* __tstate = wxPyBeginAllowThreads();
46271 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46272 wxPyEndAllowThreads(__tstate);
46273 if (PyErr_Occurred()) SWIG_fail;
46274 }
46275 {
46276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46277 }
46278 return resultobj;
46279 fail:
46280 return NULL;
46281 }
46282
46283
46284 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46285 PyObject *resultobj = 0;
46286 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46287 wxString *arg2 = 0 ;
46288 void *argp1 = 0 ;
46289 int res1 = 0 ;
46290 bool temp2 = false ;
46291 PyObject * obj0 = 0 ;
46292 PyObject * obj1 = 0 ;
46293 char * kwnames[] = {
46294 (char *) "self",(char *) "str", NULL
46295 };
46296
46297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46299 if (!SWIG_IsOK(res1)) {
46300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46301 }
46302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46303 {
46304 arg2 = wxString_in_helper(obj1);
46305 if (arg2 == NULL) SWIG_fail;
46306 temp2 = true;
46307 }
46308 {
46309 PyThreadState* __tstate = wxPyBeginAllowThreads();
46310 (arg1)->SetText((wxString const &)*arg2);
46311 wxPyEndAllowThreads(__tstate);
46312 if (PyErr_Occurred()) SWIG_fail;
46313 }
46314 resultobj = SWIG_Py_Void();
46315 {
46316 if (temp2)
46317 delete arg2;
46318 }
46319 return resultobj;
46320 fail:
46321 {
46322 if (temp2)
46323 delete arg2;
46324 }
46325 return NULL;
46326 }
46327
46328
46329 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46330 PyObject *resultobj = 0;
46331 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46332 wxString result;
46333 void *argp1 = 0 ;
46334 int res1 = 0 ;
46335 PyObject *swig_obj[1] ;
46336
46337 if (!args) SWIG_fail;
46338 swig_obj[0] = args;
46339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46340 if (!SWIG_IsOK(res1)) {
46341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46342 }
46343 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46344 {
46345 PyThreadState* __tstate = wxPyBeginAllowThreads();
46346 result = ((wxMenuItem const *)arg1)->GetLabel();
46347 wxPyEndAllowThreads(__tstate);
46348 if (PyErr_Occurred()) SWIG_fail;
46349 }
46350 {
46351 #if wxUSE_UNICODE
46352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46353 #else
46354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46355 #endif
46356 }
46357 return resultobj;
46358 fail:
46359 return NULL;
46360 }
46361
46362
46363 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46364 PyObject *resultobj = 0;
46365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46366 wxString *result = 0 ;
46367 void *argp1 = 0 ;
46368 int res1 = 0 ;
46369 PyObject *swig_obj[1] ;
46370
46371 if (!args) SWIG_fail;
46372 swig_obj[0] = args;
46373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46374 if (!SWIG_IsOK(res1)) {
46375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46376 }
46377 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46378 {
46379 PyThreadState* __tstate = wxPyBeginAllowThreads();
46380 {
46381 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46382 result = (wxString *) &_result_ref;
46383 }
46384 wxPyEndAllowThreads(__tstate);
46385 if (PyErr_Occurred()) SWIG_fail;
46386 }
46387 {
46388 #if wxUSE_UNICODE
46389 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46390 #else
46391 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46392 #endif
46393 }
46394 return resultobj;
46395 fail:
46396 return NULL;
46397 }
46398
46399
46400 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46401 PyObject *resultobj = 0;
46402 wxString *arg1 = 0 ;
46403 wxString result;
46404 bool temp1 = false ;
46405 PyObject * obj0 = 0 ;
46406 char * kwnames[] = {
46407 (char *) "text", NULL
46408 };
46409
46410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46411 {
46412 arg1 = wxString_in_helper(obj0);
46413 if (arg1 == NULL) SWIG_fail;
46414 temp1 = true;
46415 }
46416 {
46417 PyThreadState* __tstate = wxPyBeginAllowThreads();
46418 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46419 wxPyEndAllowThreads(__tstate);
46420 if (PyErr_Occurred()) SWIG_fail;
46421 }
46422 {
46423 #if wxUSE_UNICODE
46424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46425 #else
46426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46427 #endif
46428 }
46429 {
46430 if (temp1)
46431 delete arg1;
46432 }
46433 return resultobj;
46434 fail:
46435 {
46436 if (temp1)
46437 delete arg1;
46438 }
46439 return NULL;
46440 }
46441
46442
46443 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46444 PyObject *resultobj = 0;
46445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46446 wxItemKind result;
46447 void *argp1 = 0 ;
46448 int res1 = 0 ;
46449 PyObject *swig_obj[1] ;
46450
46451 if (!args) SWIG_fail;
46452 swig_obj[0] = args;
46453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46454 if (!SWIG_IsOK(res1)) {
46455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46456 }
46457 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46458 {
46459 PyThreadState* __tstate = wxPyBeginAllowThreads();
46460 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46461 wxPyEndAllowThreads(__tstate);
46462 if (PyErr_Occurred()) SWIG_fail;
46463 }
46464 resultobj = SWIG_From_int(static_cast< int >(result));
46465 return resultobj;
46466 fail:
46467 return NULL;
46468 }
46469
46470
46471 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46472 PyObject *resultobj = 0;
46473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46474 wxItemKind arg2 ;
46475 void *argp1 = 0 ;
46476 int res1 = 0 ;
46477 int val2 ;
46478 int ecode2 = 0 ;
46479 PyObject * obj0 = 0 ;
46480 PyObject * obj1 = 0 ;
46481 char * kwnames[] = {
46482 (char *) "self",(char *) "kind", NULL
46483 };
46484
46485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46487 if (!SWIG_IsOK(res1)) {
46488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46489 }
46490 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46491 ecode2 = SWIG_AsVal_int(obj1, &val2);
46492 if (!SWIG_IsOK(ecode2)) {
46493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46494 }
46495 arg2 = static_cast< wxItemKind >(val2);
46496 {
46497 PyThreadState* __tstate = wxPyBeginAllowThreads();
46498 (arg1)->SetKind(arg2);
46499 wxPyEndAllowThreads(__tstate);
46500 if (PyErr_Occurred()) SWIG_fail;
46501 }
46502 resultobj = SWIG_Py_Void();
46503 return resultobj;
46504 fail:
46505 return NULL;
46506 }
46507
46508
46509 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46510 PyObject *resultobj = 0;
46511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46512 bool arg2 ;
46513 void *argp1 = 0 ;
46514 int res1 = 0 ;
46515 bool val2 ;
46516 int ecode2 = 0 ;
46517 PyObject * obj0 = 0 ;
46518 PyObject * obj1 = 0 ;
46519 char * kwnames[] = {
46520 (char *) "self",(char *) "checkable", NULL
46521 };
46522
46523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46525 if (!SWIG_IsOK(res1)) {
46526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46527 }
46528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46529 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46530 if (!SWIG_IsOK(ecode2)) {
46531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46532 }
46533 arg2 = static_cast< bool >(val2);
46534 {
46535 PyThreadState* __tstate = wxPyBeginAllowThreads();
46536 (arg1)->SetCheckable(arg2);
46537 wxPyEndAllowThreads(__tstate);
46538 if (PyErr_Occurred()) SWIG_fail;
46539 }
46540 resultobj = SWIG_Py_Void();
46541 return resultobj;
46542 fail:
46543 return NULL;
46544 }
46545
46546
46547 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46548 PyObject *resultobj = 0;
46549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46550 bool result;
46551 void *argp1 = 0 ;
46552 int res1 = 0 ;
46553 PyObject *swig_obj[1] ;
46554
46555 if (!args) SWIG_fail;
46556 swig_obj[0] = args;
46557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46558 if (!SWIG_IsOK(res1)) {
46559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46560 }
46561 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46562 {
46563 PyThreadState* __tstate = wxPyBeginAllowThreads();
46564 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46565 wxPyEndAllowThreads(__tstate);
46566 if (PyErr_Occurred()) SWIG_fail;
46567 }
46568 {
46569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46570 }
46571 return resultobj;
46572 fail:
46573 return NULL;
46574 }
46575
46576
46577 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46578 PyObject *resultobj = 0;
46579 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46580 bool result;
46581 void *argp1 = 0 ;
46582 int res1 = 0 ;
46583 PyObject *swig_obj[1] ;
46584
46585 if (!args) SWIG_fail;
46586 swig_obj[0] = args;
46587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46588 if (!SWIG_IsOK(res1)) {
46589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46590 }
46591 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46592 {
46593 PyThreadState* __tstate = wxPyBeginAllowThreads();
46594 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46595 wxPyEndAllowThreads(__tstate);
46596 if (PyErr_Occurred()) SWIG_fail;
46597 }
46598 {
46599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46600 }
46601 return resultobj;
46602 fail:
46603 return NULL;
46604 }
46605
46606
46607 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46608 PyObject *resultobj = 0;
46609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46610 wxMenu *arg2 = (wxMenu *) 0 ;
46611 void *argp1 = 0 ;
46612 int res1 = 0 ;
46613 void *argp2 = 0 ;
46614 int res2 = 0 ;
46615 PyObject * obj0 = 0 ;
46616 PyObject * obj1 = 0 ;
46617 char * kwnames[] = {
46618 (char *) "self",(char *) "menu", NULL
46619 };
46620
46621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46623 if (!SWIG_IsOK(res1)) {
46624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46625 }
46626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46628 if (!SWIG_IsOK(res2)) {
46629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46630 }
46631 arg2 = reinterpret_cast< wxMenu * >(argp2);
46632 {
46633 PyThreadState* __tstate = wxPyBeginAllowThreads();
46634 (arg1)->SetSubMenu(arg2);
46635 wxPyEndAllowThreads(__tstate);
46636 if (PyErr_Occurred()) SWIG_fail;
46637 }
46638 resultobj = SWIG_Py_Void();
46639 return resultobj;
46640 fail:
46641 return NULL;
46642 }
46643
46644
46645 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46646 PyObject *resultobj = 0;
46647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46648 wxMenu *result = 0 ;
46649 void *argp1 = 0 ;
46650 int res1 = 0 ;
46651 PyObject *swig_obj[1] ;
46652
46653 if (!args) SWIG_fail;
46654 swig_obj[0] = args;
46655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46656 if (!SWIG_IsOK(res1)) {
46657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46658 }
46659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46660 {
46661 PyThreadState* __tstate = wxPyBeginAllowThreads();
46662 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46663 wxPyEndAllowThreads(__tstate);
46664 if (PyErr_Occurred()) SWIG_fail;
46665 }
46666 {
46667 resultobj = wxPyMake_wxObject(result, 0);
46668 }
46669 return resultobj;
46670 fail:
46671 return NULL;
46672 }
46673
46674
46675 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46676 PyObject *resultobj = 0;
46677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46678 bool arg2 = (bool) true ;
46679 void *argp1 = 0 ;
46680 int res1 = 0 ;
46681 bool val2 ;
46682 int ecode2 = 0 ;
46683 PyObject * obj0 = 0 ;
46684 PyObject * obj1 = 0 ;
46685 char * kwnames[] = {
46686 (char *) "self",(char *) "enable", NULL
46687 };
46688
46689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46691 if (!SWIG_IsOK(res1)) {
46692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46693 }
46694 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46695 if (obj1) {
46696 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46697 if (!SWIG_IsOK(ecode2)) {
46698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46699 }
46700 arg2 = static_cast< bool >(val2);
46701 }
46702 {
46703 PyThreadState* __tstate = wxPyBeginAllowThreads();
46704 (arg1)->Enable(arg2);
46705 wxPyEndAllowThreads(__tstate);
46706 if (PyErr_Occurred()) SWIG_fail;
46707 }
46708 resultobj = SWIG_Py_Void();
46709 return resultobj;
46710 fail:
46711 return NULL;
46712 }
46713
46714
46715 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46716 PyObject *resultobj = 0;
46717 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46718 bool result;
46719 void *argp1 = 0 ;
46720 int res1 = 0 ;
46721 PyObject *swig_obj[1] ;
46722
46723 if (!args) SWIG_fail;
46724 swig_obj[0] = args;
46725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46726 if (!SWIG_IsOK(res1)) {
46727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46728 }
46729 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46730 {
46731 PyThreadState* __tstate = wxPyBeginAllowThreads();
46732 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46733 wxPyEndAllowThreads(__tstate);
46734 if (PyErr_Occurred()) SWIG_fail;
46735 }
46736 {
46737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46738 }
46739 return resultobj;
46740 fail:
46741 return NULL;
46742 }
46743
46744
46745 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46746 PyObject *resultobj = 0;
46747 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46748 bool arg2 = (bool) true ;
46749 void *argp1 = 0 ;
46750 int res1 = 0 ;
46751 bool val2 ;
46752 int ecode2 = 0 ;
46753 PyObject * obj0 = 0 ;
46754 PyObject * obj1 = 0 ;
46755 char * kwnames[] = {
46756 (char *) "self",(char *) "check", NULL
46757 };
46758
46759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46761 if (!SWIG_IsOK(res1)) {
46762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46763 }
46764 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46765 if (obj1) {
46766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46767 if (!SWIG_IsOK(ecode2)) {
46768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46769 }
46770 arg2 = static_cast< bool >(val2);
46771 }
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 (arg1)->Check(arg2);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_Py_Void();
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46786 PyObject *resultobj = 0;
46787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46788 bool result;
46789 void *argp1 = 0 ;
46790 int res1 = 0 ;
46791 PyObject *swig_obj[1] ;
46792
46793 if (!args) SWIG_fail;
46794 swig_obj[0] = args;
46795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46796 if (!SWIG_IsOK(res1)) {
46797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46798 }
46799 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46800 {
46801 PyThreadState* __tstate = wxPyBeginAllowThreads();
46802 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46803 wxPyEndAllowThreads(__tstate);
46804 if (PyErr_Occurred()) SWIG_fail;
46805 }
46806 {
46807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46808 }
46809 return resultobj;
46810 fail:
46811 return NULL;
46812 }
46813
46814
46815 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46816 PyObject *resultobj = 0;
46817 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46818 void *argp1 = 0 ;
46819 int res1 = 0 ;
46820 PyObject *swig_obj[1] ;
46821
46822 if (!args) SWIG_fail;
46823 swig_obj[0] = args;
46824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46825 if (!SWIG_IsOK(res1)) {
46826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46827 }
46828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46829 {
46830 PyThreadState* __tstate = wxPyBeginAllowThreads();
46831 (arg1)->Toggle();
46832 wxPyEndAllowThreads(__tstate);
46833 if (PyErr_Occurred()) SWIG_fail;
46834 }
46835 resultobj = SWIG_Py_Void();
46836 return resultobj;
46837 fail:
46838 return NULL;
46839 }
46840
46841
46842 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46843 PyObject *resultobj = 0;
46844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46845 wxString *arg2 = 0 ;
46846 void *argp1 = 0 ;
46847 int res1 = 0 ;
46848 bool temp2 = false ;
46849 PyObject * obj0 = 0 ;
46850 PyObject * obj1 = 0 ;
46851 char * kwnames[] = {
46852 (char *) "self",(char *) "str", NULL
46853 };
46854
46855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46857 if (!SWIG_IsOK(res1)) {
46858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46859 }
46860 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46861 {
46862 arg2 = wxString_in_helper(obj1);
46863 if (arg2 == NULL) SWIG_fail;
46864 temp2 = true;
46865 }
46866 {
46867 PyThreadState* __tstate = wxPyBeginAllowThreads();
46868 (arg1)->SetHelp((wxString const &)*arg2);
46869 wxPyEndAllowThreads(__tstate);
46870 if (PyErr_Occurred()) SWIG_fail;
46871 }
46872 resultobj = SWIG_Py_Void();
46873 {
46874 if (temp2)
46875 delete arg2;
46876 }
46877 return resultobj;
46878 fail:
46879 {
46880 if (temp2)
46881 delete arg2;
46882 }
46883 return NULL;
46884 }
46885
46886
46887 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46888 PyObject *resultobj = 0;
46889 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46890 wxString *result = 0 ;
46891 void *argp1 = 0 ;
46892 int res1 = 0 ;
46893 PyObject *swig_obj[1] ;
46894
46895 if (!args) SWIG_fail;
46896 swig_obj[0] = args;
46897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46898 if (!SWIG_IsOK(res1)) {
46899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46900 }
46901 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46902 {
46903 PyThreadState* __tstate = wxPyBeginAllowThreads();
46904 {
46905 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46906 result = (wxString *) &_result_ref;
46907 }
46908 wxPyEndAllowThreads(__tstate);
46909 if (PyErr_Occurred()) SWIG_fail;
46910 }
46911 {
46912 #if wxUSE_UNICODE
46913 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46914 #else
46915 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46916 #endif
46917 }
46918 return resultobj;
46919 fail:
46920 return NULL;
46921 }
46922
46923
46924 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46925 PyObject *resultobj = 0;
46926 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46927 wxAcceleratorEntry *result = 0 ;
46928 void *argp1 = 0 ;
46929 int res1 = 0 ;
46930 PyObject *swig_obj[1] ;
46931
46932 if (!args) SWIG_fail;
46933 swig_obj[0] = args;
46934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46935 if (!SWIG_IsOK(res1)) {
46936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46937 }
46938 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46939 {
46940 PyThreadState* __tstate = wxPyBeginAllowThreads();
46941 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46942 wxPyEndAllowThreads(__tstate);
46943 if (PyErr_Occurred()) SWIG_fail;
46944 }
46945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46946 return resultobj;
46947 fail:
46948 return NULL;
46949 }
46950
46951
46952 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46953 PyObject *resultobj = 0;
46954 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46955 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46956 void *argp1 = 0 ;
46957 int res1 = 0 ;
46958 void *argp2 = 0 ;
46959 int res2 = 0 ;
46960 PyObject * obj0 = 0 ;
46961 PyObject * obj1 = 0 ;
46962 char * kwnames[] = {
46963 (char *) "self",(char *) "accel", NULL
46964 };
46965
46966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46968 if (!SWIG_IsOK(res1)) {
46969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46970 }
46971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46973 if (!SWIG_IsOK(res2)) {
46974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46975 }
46976 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46977 {
46978 PyThreadState* __tstate = wxPyBeginAllowThreads();
46979 (arg1)->SetAccel(arg2);
46980 wxPyEndAllowThreads(__tstate);
46981 if (PyErr_Occurred()) SWIG_fail;
46982 }
46983 resultobj = SWIG_Py_Void();
46984 return resultobj;
46985 fail:
46986 return NULL;
46987 }
46988
46989
46990 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46991 PyObject *resultobj = 0;
46992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46993 wxBitmap *arg2 = 0 ;
46994 void *argp1 = 0 ;
46995 int res1 = 0 ;
46996 void *argp2 = 0 ;
46997 int res2 = 0 ;
46998 PyObject * obj0 = 0 ;
46999 PyObject * obj1 = 0 ;
47000 char * kwnames[] = {
47001 (char *) "self",(char *) "bitmap", NULL
47002 };
47003
47004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47006 if (!SWIG_IsOK(res1)) {
47007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47008 }
47009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47010 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47011 if (!SWIG_IsOK(res2)) {
47012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47013 }
47014 if (!argp2) {
47015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47016 }
47017 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47018 {
47019 PyThreadState* __tstate = wxPyBeginAllowThreads();
47020 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47021 wxPyEndAllowThreads(__tstate);
47022 if (PyErr_Occurred()) SWIG_fail;
47023 }
47024 resultobj = SWIG_Py_Void();
47025 return resultobj;
47026 fail:
47027 return NULL;
47028 }
47029
47030
47031 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47032 PyObject *resultobj = 0;
47033 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47034 wxBitmap *result = 0 ;
47035 void *argp1 = 0 ;
47036 int res1 = 0 ;
47037 PyObject *swig_obj[1] ;
47038
47039 if (!args) SWIG_fail;
47040 swig_obj[0] = args;
47041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47042 if (!SWIG_IsOK(res1)) {
47043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47044 }
47045 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47046 {
47047 PyThreadState* __tstate = wxPyBeginAllowThreads();
47048 {
47049 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47050 result = (wxBitmap *) &_result_ref;
47051 }
47052 wxPyEndAllowThreads(__tstate);
47053 if (PyErr_Occurred()) SWIG_fail;
47054 }
47055 {
47056 wxBitmap* resultptr = new wxBitmap(*result);
47057 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47058 }
47059 return resultobj;
47060 fail:
47061 return NULL;
47062 }
47063
47064
47065 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47066 PyObject *resultobj = 0;
47067 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47068 wxFont *arg2 = 0 ;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 void *argp2 = 0 ;
47072 int res2 = 0 ;
47073 PyObject * obj0 = 0 ;
47074 PyObject * obj1 = 0 ;
47075 char * kwnames[] = {
47076 (char *) "self",(char *) "font", NULL
47077 };
47078
47079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47081 if (!SWIG_IsOK(res1)) {
47082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47083 }
47084 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47085 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47086 if (!SWIG_IsOK(res2)) {
47087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47088 }
47089 if (!argp2) {
47090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47091 }
47092 arg2 = reinterpret_cast< wxFont * >(argp2);
47093 {
47094 PyThreadState* __tstate = wxPyBeginAllowThreads();
47095 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47096 wxPyEndAllowThreads(__tstate);
47097 if (PyErr_Occurred()) SWIG_fail;
47098 }
47099 resultobj = SWIG_Py_Void();
47100 return resultobj;
47101 fail:
47102 return NULL;
47103 }
47104
47105
47106 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47107 PyObject *resultobj = 0;
47108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47109 wxFont result;
47110 void *argp1 = 0 ;
47111 int res1 = 0 ;
47112 PyObject *swig_obj[1] ;
47113
47114 if (!args) SWIG_fail;
47115 swig_obj[0] = args;
47116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47117 if (!SWIG_IsOK(res1)) {
47118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47119 }
47120 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47121 {
47122 PyThreadState* __tstate = wxPyBeginAllowThreads();
47123 result = wxMenuItem_GetFont(arg1);
47124 wxPyEndAllowThreads(__tstate);
47125 if (PyErr_Occurred()) SWIG_fail;
47126 }
47127 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47128 return resultobj;
47129 fail:
47130 return NULL;
47131 }
47132
47133
47134 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47135 PyObject *resultobj = 0;
47136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47137 wxColour *arg2 = 0 ;
47138 void *argp1 = 0 ;
47139 int res1 = 0 ;
47140 wxColour temp2 ;
47141 PyObject * obj0 = 0 ;
47142 PyObject * obj1 = 0 ;
47143 char * kwnames[] = {
47144 (char *) "self",(char *) "colText", NULL
47145 };
47146
47147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47149 if (!SWIG_IsOK(res1)) {
47150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47151 }
47152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47153 {
47154 arg2 = &temp2;
47155 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47156 }
47157 {
47158 PyThreadState* __tstate = wxPyBeginAllowThreads();
47159 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47160 wxPyEndAllowThreads(__tstate);
47161 if (PyErr_Occurred()) SWIG_fail;
47162 }
47163 resultobj = SWIG_Py_Void();
47164 return resultobj;
47165 fail:
47166 return NULL;
47167 }
47168
47169
47170 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47171 PyObject *resultobj = 0;
47172 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47173 wxColour result;
47174 void *argp1 = 0 ;
47175 int res1 = 0 ;
47176 PyObject *swig_obj[1] ;
47177
47178 if (!args) SWIG_fail;
47179 swig_obj[0] = args;
47180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47181 if (!SWIG_IsOK(res1)) {
47182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47183 }
47184 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47185 {
47186 PyThreadState* __tstate = wxPyBeginAllowThreads();
47187 result = wxMenuItem_GetTextColour(arg1);
47188 wxPyEndAllowThreads(__tstate);
47189 if (PyErr_Occurred()) SWIG_fail;
47190 }
47191 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47192 return resultobj;
47193 fail:
47194 return NULL;
47195 }
47196
47197
47198 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47199 PyObject *resultobj = 0;
47200 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47201 wxColour *arg2 = 0 ;
47202 void *argp1 = 0 ;
47203 int res1 = 0 ;
47204 wxColour temp2 ;
47205 PyObject * obj0 = 0 ;
47206 PyObject * obj1 = 0 ;
47207 char * kwnames[] = {
47208 (char *) "self",(char *) "colBack", NULL
47209 };
47210
47211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47213 if (!SWIG_IsOK(res1)) {
47214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47215 }
47216 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47217 {
47218 arg2 = &temp2;
47219 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47220 }
47221 {
47222 PyThreadState* __tstate = wxPyBeginAllowThreads();
47223 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47224 wxPyEndAllowThreads(__tstate);
47225 if (PyErr_Occurred()) SWIG_fail;
47226 }
47227 resultobj = SWIG_Py_Void();
47228 return resultobj;
47229 fail:
47230 return NULL;
47231 }
47232
47233
47234 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47235 PyObject *resultobj = 0;
47236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47237 wxColour result;
47238 void *argp1 = 0 ;
47239 int res1 = 0 ;
47240 PyObject *swig_obj[1] ;
47241
47242 if (!args) SWIG_fail;
47243 swig_obj[0] = args;
47244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47245 if (!SWIG_IsOK(res1)) {
47246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47247 }
47248 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47249 {
47250 PyThreadState* __tstate = wxPyBeginAllowThreads();
47251 result = wxMenuItem_GetBackgroundColour(arg1);
47252 wxPyEndAllowThreads(__tstate);
47253 if (PyErr_Occurred()) SWIG_fail;
47254 }
47255 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47256 return resultobj;
47257 fail:
47258 return NULL;
47259 }
47260
47261
47262 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47263 PyObject *resultobj = 0;
47264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47265 wxBitmap *arg2 = 0 ;
47266 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47267 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47268 void *argp1 = 0 ;
47269 int res1 = 0 ;
47270 void *argp2 = 0 ;
47271 int res2 = 0 ;
47272 void *argp3 = 0 ;
47273 int res3 = 0 ;
47274 PyObject * obj0 = 0 ;
47275 PyObject * obj1 = 0 ;
47276 PyObject * obj2 = 0 ;
47277 char * kwnames[] = {
47278 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47279 };
47280
47281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47283 if (!SWIG_IsOK(res1)) {
47284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47285 }
47286 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47288 if (!SWIG_IsOK(res2)) {
47289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47290 }
47291 if (!argp2) {
47292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47293 }
47294 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47295 if (obj2) {
47296 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47297 if (!SWIG_IsOK(res3)) {
47298 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47299 }
47300 if (!argp3) {
47301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47302 }
47303 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47304 }
47305 {
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_Py_Void();
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47319 PyObject *resultobj = 0;
47320 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47321 wxBitmap *arg2 = 0 ;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 void *argp2 = 0 ;
47325 int res2 = 0 ;
47326 PyObject * obj0 = 0 ;
47327 PyObject * obj1 = 0 ;
47328 char * kwnames[] = {
47329 (char *) "self",(char *) "bmpDisabled", NULL
47330 };
47331
47332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47334 if (!SWIG_IsOK(res1)) {
47335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47336 }
47337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47339 if (!SWIG_IsOK(res2)) {
47340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47341 }
47342 if (!argp2) {
47343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47344 }
47345 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 resultobj = SWIG_Py_Void();
47353 return resultobj;
47354 fail:
47355 return NULL;
47356 }
47357
47358
47359 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47360 PyObject *resultobj = 0;
47361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47362 wxBitmap *result = 0 ;
47363 void *argp1 = 0 ;
47364 int res1 = 0 ;
47365 PyObject *swig_obj[1] ;
47366
47367 if (!args) SWIG_fail;
47368 swig_obj[0] = args;
47369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47370 if (!SWIG_IsOK(res1)) {
47371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47372 }
47373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47374 {
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 {
47377 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47378 result = (wxBitmap *) &_result_ref;
47379 }
47380 wxPyEndAllowThreads(__tstate);
47381 if (PyErr_Occurred()) SWIG_fail;
47382 }
47383 {
47384 wxBitmap* resultptr = new wxBitmap(*result);
47385 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47386 }
47387 return resultobj;
47388 fail:
47389 return NULL;
47390 }
47391
47392
47393 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47394 PyObject *resultobj = 0;
47395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47396 int arg2 ;
47397 void *argp1 = 0 ;
47398 int res1 = 0 ;
47399 int val2 ;
47400 int ecode2 = 0 ;
47401 PyObject * obj0 = 0 ;
47402 PyObject * obj1 = 0 ;
47403 char * kwnames[] = {
47404 (char *) "self",(char *) "nWidth", NULL
47405 };
47406
47407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47409 if (!SWIG_IsOK(res1)) {
47410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47411 }
47412 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47413 ecode2 = SWIG_AsVal_int(obj1, &val2);
47414 if (!SWIG_IsOK(ecode2)) {
47415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47416 }
47417 arg2 = static_cast< int >(val2);
47418 {
47419 PyThreadState* __tstate = wxPyBeginAllowThreads();
47420 wxMenuItem_SetMarginWidth(arg1,arg2);
47421 wxPyEndAllowThreads(__tstate);
47422 if (PyErr_Occurred()) SWIG_fail;
47423 }
47424 resultobj = SWIG_Py_Void();
47425 return resultobj;
47426 fail:
47427 return NULL;
47428 }
47429
47430
47431 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47432 PyObject *resultobj = 0;
47433 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47434 int result;
47435 void *argp1 = 0 ;
47436 int res1 = 0 ;
47437 PyObject *swig_obj[1] ;
47438
47439 if (!args) SWIG_fail;
47440 swig_obj[0] = args;
47441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47442 if (!SWIG_IsOK(res1)) {
47443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47444 }
47445 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47446 {
47447 PyThreadState* __tstate = wxPyBeginAllowThreads();
47448 result = (int)wxMenuItem_GetMarginWidth(arg1);
47449 wxPyEndAllowThreads(__tstate);
47450 if (PyErr_Occurred()) SWIG_fail;
47451 }
47452 resultobj = SWIG_From_int(static_cast< int >(result));
47453 return resultobj;
47454 fail:
47455 return NULL;
47456 }
47457
47458
47459 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47460 PyObject *resultobj = 0;
47461 int result;
47462
47463 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47464 {
47465 PyThreadState* __tstate = wxPyBeginAllowThreads();
47466 result = (int)wxMenuItem_GetDefaultMarginWidth();
47467 wxPyEndAllowThreads(__tstate);
47468 if (PyErr_Occurred()) SWIG_fail;
47469 }
47470 resultobj = SWIG_From_int(static_cast< int >(result));
47471 return resultobj;
47472 fail:
47473 return NULL;
47474 }
47475
47476
47477 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47478 PyObject *resultobj = 0;
47479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47480 bool result;
47481 void *argp1 = 0 ;
47482 int res1 = 0 ;
47483 PyObject *swig_obj[1] ;
47484
47485 if (!args) SWIG_fail;
47486 swig_obj[0] = args;
47487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47488 if (!SWIG_IsOK(res1)) {
47489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47490 }
47491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47492 {
47493 PyThreadState* __tstate = wxPyBeginAllowThreads();
47494 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47495 wxPyEndAllowThreads(__tstate);
47496 if (PyErr_Occurred()) SWIG_fail;
47497 }
47498 {
47499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47500 }
47501 return resultobj;
47502 fail:
47503 return NULL;
47504 }
47505
47506
47507 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47508 PyObject *resultobj = 0;
47509 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47510 bool arg2 = (bool) true ;
47511 void *argp1 = 0 ;
47512 int res1 = 0 ;
47513 bool val2 ;
47514 int ecode2 = 0 ;
47515 PyObject * obj0 = 0 ;
47516 PyObject * obj1 = 0 ;
47517 char * kwnames[] = {
47518 (char *) "self",(char *) "ownerDrawn", NULL
47519 };
47520
47521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47523 if (!SWIG_IsOK(res1)) {
47524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47525 }
47526 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47527 if (obj1) {
47528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47529 if (!SWIG_IsOK(ecode2)) {
47530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47531 }
47532 arg2 = static_cast< bool >(val2);
47533 }
47534 {
47535 PyThreadState* __tstate = wxPyBeginAllowThreads();
47536 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47537 wxPyEndAllowThreads(__tstate);
47538 if (PyErr_Occurred()) SWIG_fail;
47539 }
47540 resultobj = SWIG_Py_Void();
47541 return resultobj;
47542 fail:
47543 return NULL;
47544 }
47545
47546
47547 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47548 PyObject *resultobj = 0;
47549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47550 void *argp1 = 0 ;
47551 int res1 = 0 ;
47552 PyObject *swig_obj[1] ;
47553
47554 if (!args) SWIG_fail;
47555 swig_obj[0] = args;
47556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47557 if (!SWIG_IsOK(res1)) {
47558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47559 }
47560 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47561 {
47562 PyThreadState* __tstate = wxPyBeginAllowThreads();
47563 wxMenuItem_ResetOwnerDrawn(arg1);
47564 wxPyEndAllowThreads(__tstate);
47565 if (PyErr_Occurred()) SWIG_fail;
47566 }
47567 resultobj = SWIG_Py_Void();
47568 return resultobj;
47569 fail:
47570 return NULL;
47571 }
47572
47573
47574 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47575 PyObject *obj;
47576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47577 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47578 return SWIG_Py_Void();
47579 }
47580
47581 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47582 return SWIG_Python_InitShadowInstance(args);
47583 }
47584
47585 SWIGINTERN int ControlNameStr_set(PyObject *) {
47586 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47587 return 1;
47588 }
47589
47590
47591 SWIGINTERN PyObject *ControlNameStr_get(void) {
47592 PyObject *pyobj = 0;
47593
47594 {
47595 #if wxUSE_UNICODE
47596 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47597 #else
47598 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47599 #endif
47600 }
47601 return pyobj;
47602 }
47603
47604
47605 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47606 PyObject *resultobj = 0;
47607 wxWindow *arg1 = (wxWindow *) 0 ;
47608 int arg2 = (int) -1 ;
47609 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47610 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47611 wxSize const &arg4_defvalue = wxDefaultSize ;
47612 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47613 long arg5 = (long) 0 ;
47614 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47615 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47616 wxString const &arg7_defvalue = wxPyControlNameStr ;
47617 wxString *arg7 = (wxString *) &arg7_defvalue ;
47618 wxControl *result = 0 ;
47619 void *argp1 = 0 ;
47620 int res1 = 0 ;
47621 int val2 ;
47622 int ecode2 = 0 ;
47623 wxPoint temp3 ;
47624 wxSize temp4 ;
47625 long val5 ;
47626 int ecode5 = 0 ;
47627 void *argp6 = 0 ;
47628 int res6 = 0 ;
47629 bool temp7 = false ;
47630 PyObject * obj0 = 0 ;
47631 PyObject * obj1 = 0 ;
47632 PyObject * obj2 = 0 ;
47633 PyObject * obj3 = 0 ;
47634 PyObject * obj4 = 0 ;
47635 PyObject * obj5 = 0 ;
47636 PyObject * obj6 = 0 ;
47637 char * kwnames[] = {
47638 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47639 };
47640
47641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47643 if (!SWIG_IsOK(res1)) {
47644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47645 }
47646 arg1 = reinterpret_cast< wxWindow * >(argp1);
47647 if (obj1) {
47648 ecode2 = SWIG_AsVal_int(obj1, &val2);
47649 if (!SWIG_IsOK(ecode2)) {
47650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47651 }
47652 arg2 = static_cast< int >(val2);
47653 }
47654 if (obj2) {
47655 {
47656 arg3 = &temp3;
47657 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47658 }
47659 }
47660 if (obj3) {
47661 {
47662 arg4 = &temp4;
47663 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47664 }
47665 }
47666 if (obj4) {
47667 ecode5 = SWIG_AsVal_long(obj4, &val5);
47668 if (!SWIG_IsOK(ecode5)) {
47669 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47670 }
47671 arg5 = static_cast< long >(val5);
47672 }
47673 if (obj5) {
47674 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47675 if (!SWIG_IsOK(res6)) {
47676 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47677 }
47678 if (!argp6) {
47679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47680 }
47681 arg6 = reinterpret_cast< wxValidator * >(argp6);
47682 }
47683 if (obj6) {
47684 {
47685 arg7 = wxString_in_helper(obj6);
47686 if (arg7 == NULL) SWIG_fail;
47687 temp7 = true;
47688 }
47689 }
47690 {
47691 if (!wxPyCheckForApp()) SWIG_fail;
47692 PyThreadState* __tstate = wxPyBeginAllowThreads();
47693 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47694 wxPyEndAllowThreads(__tstate);
47695 if (PyErr_Occurred()) SWIG_fail;
47696 }
47697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47698 {
47699 if (temp7)
47700 delete arg7;
47701 }
47702 return resultobj;
47703 fail:
47704 {
47705 if (temp7)
47706 delete arg7;
47707 }
47708 return NULL;
47709 }
47710
47711
47712 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47713 PyObject *resultobj = 0;
47714 wxControl *result = 0 ;
47715
47716 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47717 {
47718 if (!wxPyCheckForApp()) SWIG_fail;
47719 PyThreadState* __tstate = wxPyBeginAllowThreads();
47720 result = (wxControl *)new wxControl();
47721 wxPyEndAllowThreads(__tstate);
47722 if (PyErr_Occurred()) SWIG_fail;
47723 }
47724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47725 return resultobj;
47726 fail:
47727 return NULL;
47728 }
47729
47730
47731 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47732 PyObject *resultobj = 0;
47733 wxControl *arg1 = (wxControl *) 0 ;
47734 wxWindow *arg2 = (wxWindow *) 0 ;
47735 int arg3 = (int) -1 ;
47736 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47737 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47738 wxSize const &arg5_defvalue = wxDefaultSize ;
47739 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47740 long arg6 = (long) 0 ;
47741 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47742 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47743 wxString const &arg8_defvalue = wxPyControlNameStr ;
47744 wxString *arg8 = (wxString *) &arg8_defvalue ;
47745 bool result;
47746 void *argp1 = 0 ;
47747 int res1 = 0 ;
47748 void *argp2 = 0 ;
47749 int res2 = 0 ;
47750 int val3 ;
47751 int ecode3 = 0 ;
47752 wxPoint temp4 ;
47753 wxSize temp5 ;
47754 long val6 ;
47755 int ecode6 = 0 ;
47756 void *argp7 = 0 ;
47757 int res7 = 0 ;
47758 bool temp8 = false ;
47759 PyObject * obj0 = 0 ;
47760 PyObject * obj1 = 0 ;
47761 PyObject * obj2 = 0 ;
47762 PyObject * obj3 = 0 ;
47763 PyObject * obj4 = 0 ;
47764 PyObject * obj5 = 0 ;
47765 PyObject * obj6 = 0 ;
47766 PyObject * obj7 = 0 ;
47767 char * kwnames[] = {
47768 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47769 };
47770
47771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47773 if (!SWIG_IsOK(res1)) {
47774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47775 }
47776 arg1 = reinterpret_cast< wxControl * >(argp1);
47777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47778 if (!SWIG_IsOK(res2)) {
47779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47780 }
47781 arg2 = reinterpret_cast< wxWindow * >(argp2);
47782 if (obj2) {
47783 ecode3 = SWIG_AsVal_int(obj2, &val3);
47784 if (!SWIG_IsOK(ecode3)) {
47785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47786 }
47787 arg3 = static_cast< int >(val3);
47788 }
47789 if (obj3) {
47790 {
47791 arg4 = &temp4;
47792 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47793 }
47794 }
47795 if (obj4) {
47796 {
47797 arg5 = &temp5;
47798 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47799 }
47800 }
47801 if (obj5) {
47802 ecode6 = SWIG_AsVal_long(obj5, &val6);
47803 if (!SWIG_IsOK(ecode6)) {
47804 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47805 }
47806 arg6 = static_cast< long >(val6);
47807 }
47808 if (obj6) {
47809 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47810 if (!SWIG_IsOK(res7)) {
47811 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47812 }
47813 if (!argp7) {
47814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47815 }
47816 arg7 = reinterpret_cast< wxValidator * >(argp7);
47817 }
47818 if (obj7) {
47819 {
47820 arg8 = wxString_in_helper(obj7);
47821 if (arg8 == NULL) SWIG_fail;
47822 temp8 = true;
47823 }
47824 }
47825 {
47826 PyThreadState* __tstate = wxPyBeginAllowThreads();
47827 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47828 wxPyEndAllowThreads(__tstate);
47829 if (PyErr_Occurred()) SWIG_fail;
47830 }
47831 {
47832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47833 }
47834 {
47835 if (temp8)
47836 delete arg8;
47837 }
47838 return resultobj;
47839 fail:
47840 {
47841 if (temp8)
47842 delete arg8;
47843 }
47844 return NULL;
47845 }
47846
47847
47848 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47849 PyObject *resultobj = 0;
47850 wxControl *arg1 = (wxControl *) 0 ;
47851 int result;
47852 void *argp1 = 0 ;
47853 int res1 = 0 ;
47854 PyObject *swig_obj[1] ;
47855
47856 if (!args) SWIG_fail;
47857 swig_obj[0] = args;
47858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47859 if (!SWIG_IsOK(res1)) {
47860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47861 }
47862 arg1 = reinterpret_cast< wxControl * >(argp1);
47863 {
47864 PyThreadState* __tstate = wxPyBeginAllowThreads();
47865 result = (int)((wxControl const *)arg1)->GetAlignment();
47866 wxPyEndAllowThreads(__tstate);
47867 if (PyErr_Occurred()) SWIG_fail;
47868 }
47869 resultobj = SWIG_From_int(static_cast< int >(result));
47870 return resultobj;
47871 fail:
47872 return NULL;
47873 }
47874
47875
47876 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47877 PyObject *resultobj = 0;
47878 wxControl *arg1 = (wxControl *) 0 ;
47879 wxString result;
47880 void *argp1 = 0 ;
47881 int res1 = 0 ;
47882 PyObject *swig_obj[1] ;
47883
47884 if (!args) SWIG_fail;
47885 swig_obj[0] = args;
47886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47887 if (!SWIG_IsOK(res1)) {
47888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47889 }
47890 arg1 = reinterpret_cast< wxControl * >(argp1);
47891 {
47892 PyThreadState* __tstate = wxPyBeginAllowThreads();
47893 result = ((wxControl const *)arg1)->GetLabelText();
47894 wxPyEndAllowThreads(__tstate);
47895 if (PyErr_Occurred()) SWIG_fail;
47896 }
47897 {
47898 #if wxUSE_UNICODE
47899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47900 #else
47901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47902 #endif
47903 }
47904 return resultobj;
47905 fail:
47906 return NULL;
47907 }
47908
47909
47910 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47911 PyObject *resultobj = 0;
47912 wxControl *arg1 = (wxControl *) 0 ;
47913 wxCommandEvent *arg2 = 0 ;
47914 void *argp1 = 0 ;
47915 int res1 = 0 ;
47916 void *argp2 = 0 ;
47917 int res2 = 0 ;
47918 PyObject * obj0 = 0 ;
47919 PyObject * obj1 = 0 ;
47920 char * kwnames[] = {
47921 (char *) "self",(char *) "event", NULL
47922 };
47923
47924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47926 if (!SWIG_IsOK(res1)) {
47927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47928 }
47929 arg1 = reinterpret_cast< wxControl * >(argp1);
47930 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47931 if (!SWIG_IsOK(res2)) {
47932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47933 }
47934 if (!argp2) {
47935 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47936 }
47937 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47938 {
47939 PyThreadState* __tstate = wxPyBeginAllowThreads();
47940 (arg1)->Command(*arg2);
47941 wxPyEndAllowThreads(__tstate);
47942 if (PyErr_Occurred()) SWIG_fail;
47943 }
47944 resultobj = SWIG_Py_Void();
47945 return resultobj;
47946 fail:
47947 return NULL;
47948 }
47949
47950
47951 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47952 PyObject *resultobj = 0;
47953 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47954 SwigValueWrapper<wxVisualAttributes > result;
47955 int val1 ;
47956 int ecode1 = 0 ;
47957 PyObject * obj0 = 0 ;
47958 char * kwnames[] = {
47959 (char *) "variant", NULL
47960 };
47961
47962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47963 if (obj0) {
47964 ecode1 = SWIG_AsVal_int(obj0, &val1);
47965 if (!SWIG_IsOK(ecode1)) {
47966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47967 }
47968 arg1 = static_cast< wxWindowVariant >(val1);
47969 }
47970 {
47971 if (!wxPyCheckForApp()) SWIG_fail;
47972 PyThreadState* __tstate = wxPyBeginAllowThreads();
47973 result = wxControl::GetClassDefaultAttributes(arg1);
47974 wxPyEndAllowThreads(__tstate);
47975 if (PyErr_Occurred()) SWIG_fail;
47976 }
47977 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47978 return resultobj;
47979 fail:
47980 return NULL;
47981 }
47982
47983
47984 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47985 PyObject *obj;
47986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47987 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47988 return SWIG_Py_Void();
47989 }
47990
47991 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47992 return SWIG_Python_InitShadowInstance(args);
47993 }
47994
47995 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47996 PyObject *resultobj = 0;
47997 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47998 wxString *arg2 = 0 ;
47999 PyObject *arg3 = (PyObject *) NULL ;
48000 int result;
48001 void *argp1 = 0 ;
48002 int res1 = 0 ;
48003 bool temp2 = false ;
48004 PyObject * obj0 = 0 ;
48005 PyObject * obj1 = 0 ;
48006 PyObject * obj2 = 0 ;
48007 char * kwnames[] = {
48008 (char *) "self",(char *) "item",(char *) "clientData", NULL
48009 };
48010
48011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48013 if (!SWIG_IsOK(res1)) {
48014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48015 }
48016 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48017 {
48018 arg2 = wxString_in_helper(obj1);
48019 if (arg2 == NULL) SWIG_fail;
48020 temp2 = true;
48021 }
48022 if (obj2) {
48023 arg3 = obj2;
48024 }
48025 {
48026 PyThreadState* __tstate = wxPyBeginAllowThreads();
48027 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48028 wxPyEndAllowThreads(__tstate);
48029 if (PyErr_Occurred()) SWIG_fail;
48030 }
48031 resultobj = SWIG_From_int(static_cast< int >(result));
48032 {
48033 if (temp2)
48034 delete arg2;
48035 }
48036 return resultobj;
48037 fail:
48038 {
48039 if (temp2)
48040 delete arg2;
48041 }
48042 return NULL;
48043 }
48044
48045
48046 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48047 PyObject *resultobj = 0;
48048 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48049 wxArrayString *arg2 = 0 ;
48050 void *argp1 = 0 ;
48051 int res1 = 0 ;
48052 bool temp2 = false ;
48053 PyObject * obj0 = 0 ;
48054 PyObject * obj1 = 0 ;
48055 char * kwnames[] = {
48056 (char *) "self",(char *) "strings", NULL
48057 };
48058
48059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48061 if (!SWIG_IsOK(res1)) {
48062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48063 }
48064 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48065 {
48066 if (! PySequence_Check(obj1)) {
48067 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48068 SWIG_fail;
48069 }
48070 arg2 = new wxArrayString;
48071 temp2 = true;
48072 int i, len=PySequence_Length(obj1);
48073 for (i=0; i<len; i++) {
48074 PyObject* item = PySequence_GetItem(obj1, i);
48075 wxString* s = wxString_in_helper(item);
48076 if (PyErr_Occurred()) SWIG_fail;
48077 arg2->Add(*s);
48078 delete s;
48079 Py_DECREF(item);
48080 }
48081 }
48082 {
48083 PyThreadState* __tstate = wxPyBeginAllowThreads();
48084 (arg1)->Append((wxArrayString const &)*arg2);
48085 wxPyEndAllowThreads(__tstate);
48086 if (PyErr_Occurred()) SWIG_fail;
48087 }
48088 resultobj = SWIG_Py_Void();
48089 {
48090 if (temp2) delete arg2;
48091 }
48092 return resultobj;
48093 fail:
48094 {
48095 if (temp2) delete arg2;
48096 }
48097 return NULL;
48098 }
48099
48100
48101 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48102 PyObject *resultobj = 0;
48103 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48104 wxString *arg2 = 0 ;
48105 int arg3 ;
48106 PyObject *arg4 = (PyObject *) NULL ;
48107 int result;
48108 void *argp1 = 0 ;
48109 int res1 = 0 ;
48110 bool temp2 = false ;
48111 int val3 ;
48112 int ecode3 = 0 ;
48113 PyObject * obj0 = 0 ;
48114 PyObject * obj1 = 0 ;
48115 PyObject * obj2 = 0 ;
48116 PyObject * obj3 = 0 ;
48117 char * kwnames[] = {
48118 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48119 };
48120
48121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48123 if (!SWIG_IsOK(res1)) {
48124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48125 }
48126 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48127 {
48128 arg2 = wxString_in_helper(obj1);
48129 if (arg2 == NULL) SWIG_fail;
48130 temp2 = true;
48131 }
48132 ecode3 = SWIG_AsVal_int(obj2, &val3);
48133 if (!SWIG_IsOK(ecode3)) {
48134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48135 }
48136 arg3 = static_cast< int >(val3);
48137 if (obj3) {
48138 arg4 = obj3;
48139 }
48140 {
48141 PyThreadState* __tstate = wxPyBeginAllowThreads();
48142 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48143 wxPyEndAllowThreads(__tstate);
48144 if (PyErr_Occurred()) SWIG_fail;
48145 }
48146 resultobj = SWIG_From_int(static_cast< int >(result));
48147 {
48148 if (temp2)
48149 delete arg2;
48150 }
48151 return resultobj;
48152 fail:
48153 {
48154 if (temp2)
48155 delete arg2;
48156 }
48157 return NULL;
48158 }
48159
48160
48161 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48162 PyObject *resultobj = 0;
48163 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48164 void *argp1 = 0 ;
48165 int res1 = 0 ;
48166 PyObject *swig_obj[1] ;
48167
48168 if (!args) SWIG_fail;
48169 swig_obj[0] = args;
48170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48171 if (!SWIG_IsOK(res1)) {
48172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48173 }
48174 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48175 {
48176 PyThreadState* __tstate = wxPyBeginAllowThreads();
48177 (arg1)->Clear();
48178 wxPyEndAllowThreads(__tstate);
48179 if (PyErr_Occurred()) SWIG_fail;
48180 }
48181 resultobj = SWIG_Py_Void();
48182 return resultobj;
48183 fail:
48184 return NULL;
48185 }
48186
48187
48188 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48189 PyObject *resultobj = 0;
48190 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48191 int arg2 ;
48192 void *argp1 = 0 ;
48193 int res1 = 0 ;
48194 int val2 ;
48195 int ecode2 = 0 ;
48196 PyObject * obj0 = 0 ;
48197 PyObject * obj1 = 0 ;
48198 char * kwnames[] = {
48199 (char *) "self",(char *) "n", NULL
48200 };
48201
48202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48204 if (!SWIG_IsOK(res1)) {
48205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48206 }
48207 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48208 ecode2 = SWIG_AsVal_int(obj1, &val2);
48209 if (!SWIG_IsOK(ecode2)) {
48210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48211 }
48212 arg2 = static_cast< int >(val2);
48213 {
48214 PyThreadState* __tstate = wxPyBeginAllowThreads();
48215 (arg1)->Delete(arg2);
48216 wxPyEndAllowThreads(__tstate);
48217 if (PyErr_Occurred()) SWIG_fail;
48218 }
48219 resultobj = SWIG_Py_Void();
48220 return resultobj;
48221 fail:
48222 return NULL;
48223 }
48224
48225
48226 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48227 PyObject *resultobj = 0;
48228 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48229 int arg2 ;
48230 PyObject *result = 0 ;
48231 void *argp1 = 0 ;
48232 int res1 = 0 ;
48233 int val2 ;
48234 int ecode2 = 0 ;
48235 PyObject * obj0 = 0 ;
48236 PyObject * obj1 = 0 ;
48237 char * kwnames[] = {
48238 (char *) "self",(char *) "n", NULL
48239 };
48240
48241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48243 if (!SWIG_IsOK(res1)) {
48244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48245 }
48246 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48247 ecode2 = SWIG_AsVal_int(obj1, &val2);
48248 if (!SWIG_IsOK(ecode2)) {
48249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48250 }
48251 arg2 = static_cast< int >(val2);
48252 {
48253 PyThreadState* __tstate = wxPyBeginAllowThreads();
48254 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48255 wxPyEndAllowThreads(__tstate);
48256 if (PyErr_Occurred()) SWIG_fail;
48257 }
48258 resultobj = result;
48259 return resultobj;
48260 fail:
48261 return NULL;
48262 }
48263
48264
48265 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48266 PyObject *resultobj = 0;
48267 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48268 int arg2 ;
48269 PyObject *arg3 = (PyObject *) 0 ;
48270 void *argp1 = 0 ;
48271 int res1 = 0 ;
48272 int val2 ;
48273 int ecode2 = 0 ;
48274 PyObject * obj0 = 0 ;
48275 PyObject * obj1 = 0 ;
48276 PyObject * obj2 = 0 ;
48277 char * kwnames[] = {
48278 (char *) "self",(char *) "n",(char *) "clientData", NULL
48279 };
48280
48281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48283 if (!SWIG_IsOK(res1)) {
48284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48285 }
48286 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48287 ecode2 = SWIG_AsVal_int(obj1, &val2);
48288 if (!SWIG_IsOK(ecode2)) {
48289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48290 }
48291 arg2 = static_cast< int >(val2);
48292 arg3 = obj2;
48293 {
48294 PyThreadState* __tstate = wxPyBeginAllowThreads();
48295 wxItemContainer_SetClientData(arg1,arg2,arg3);
48296 wxPyEndAllowThreads(__tstate);
48297 if (PyErr_Occurred()) SWIG_fail;
48298 }
48299 resultobj = SWIG_Py_Void();
48300 return resultobj;
48301 fail:
48302 return NULL;
48303 }
48304
48305
48306 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48307 PyObject *resultobj = 0;
48308 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48309 int result;
48310 void *argp1 = 0 ;
48311 int res1 = 0 ;
48312 PyObject *swig_obj[1] ;
48313
48314 if (!args) SWIG_fail;
48315 swig_obj[0] = args;
48316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48317 if (!SWIG_IsOK(res1)) {
48318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48319 }
48320 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48321 {
48322 PyThreadState* __tstate = wxPyBeginAllowThreads();
48323 result = (int)((wxItemContainer const *)arg1)->GetCount();
48324 wxPyEndAllowThreads(__tstate);
48325 if (PyErr_Occurred()) SWIG_fail;
48326 }
48327 resultobj = SWIG_From_int(static_cast< int >(result));
48328 return resultobj;
48329 fail:
48330 return NULL;
48331 }
48332
48333
48334 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48335 PyObject *resultobj = 0;
48336 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48337 bool result;
48338 void *argp1 = 0 ;
48339 int res1 = 0 ;
48340 PyObject *swig_obj[1] ;
48341
48342 if (!args) SWIG_fail;
48343 swig_obj[0] = args;
48344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48345 if (!SWIG_IsOK(res1)) {
48346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48347 }
48348 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48349 {
48350 PyThreadState* __tstate = wxPyBeginAllowThreads();
48351 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48352 wxPyEndAllowThreads(__tstate);
48353 if (PyErr_Occurred()) SWIG_fail;
48354 }
48355 {
48356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48357 }
48358 return resultobj;
48359 fail:
48360 return NULL;
48361 }
48362
48363
48364 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48365 PyObject *resultobj = 0;
48366 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48367 int arg2 ;
48368 wxString result;
48369 void *argp1 = 0 ;
48370 int res1 = 0 ;
48371 int val2 ;
48372 int ecode2 = 0 ;
48373 PyObject * obj0 = 0 ;
48374 PyObject * obj1 = 0 ;
48375 char * kwnames[] = {
48376 (char *) "self",(char *) "n", NULL
48377 };
48378
48379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48381 if (!SWIG_IsOK(res1)) {
48382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48383 }
48384 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48385 ecode2 = SWIG_AsVal_int(obj1, &val2);
48386 if (!SWIG_IsOK(ecode2)) {
48387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48388 }
48389 arg2 = static_cast< int >(val2);
48390 {
48391 PyThreadState* __tstate = wxPyBeginAllowThreads();
48392 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48393 wxPyEndAllowThreads(__tstate);
48394 if (PyErr_Occurred()) SWIG_fail;
48395 }
48396 {
48397 #if wxUSE_UNICODE
48398 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48399 #else
48400 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48401 #endif
48402 }
48403 return resultobj;
48404 fail:
48405 return NULL;
48406 }
48407
48408
48409 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48410 PyObject *resultobj = 0;
48411 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48412 wxArrayString result;
48413 void *argp1 = 0 ;
48414 int res1 = 0 ;
48415 PyObject *swig_obj[1] ;
48416
48417 if (!args) SWIG_fail;
48418 swig_obj[0] = args;
48419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48420 if (!SWIG_IsOK(res1)) {
48421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48422 }
48423 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48424 {
48425 PyThreadState* __tstate = wxPyBeginAllowThreads();
48426 result = ((wxItemContainer const *)arg1)->GetStrings();
48427 wxPyEndAllowThreads(__tstate);
48428 if (PyErr_Occurred()) SWIG_fail;
48429 }
48430 {
48431 resultobj = wxArrayString2PyList_helper(result);
48432 }
48433 return resultobj;
48434 fail:
48435 return NULL;
48436 }
48437
48438
48439 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48440 PyObject *resultobj = 0;
48441 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48442 int arg2 ;
48443 wxString *arg3 = 0 ;
48444 void *argp1 = 0 ;
48445 int res1 = 0 ;
48446 int val2 ;
48447 int ecode2 = 0 ;
48448 bool temp3 = false ;
48449 PyObject * obj0 = 0 ;
48450 PyObject * obj1 = 0 ;
48451 PyObject * obj2 = 0 ;
48452 char * kwnames[] = {
48453 (char *) "self",(char *) "n",(char *) "s", NULL
48454 };
48455
48456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48458 if (!SWIG_IsOK(res1)) {
48459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48460 }
48461 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48462 ecode2 = SWIG_AsVal_int(obj1, &val2);
48463 if (!SWIG_IsOK(ecode2)) {
48464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48465 }
48466 arg2 = static_cast< int >(val2);
48467 {
48468 arg3 = wxString_in_helper(obj2);
48469 if (arg3 == NULL) SWIG_fail;
48470 temp3 = true;
48471 }
48472 {
48473 PyThreadState* __tstate = wxPyBeginAllowThreads();
48474 (arg1)->SetString(arg2,(wxString const &)*arg3);
48475 wxPyEndAllowThreads(__tstate);
48476 if (PyErr_Occurred()) SWIG_fail;
48477 }
48478 resultobj = SWIG_Py_Void();
48479 {
48480 if (temp3)
48481 delete arg3;
48482 }
48483 return resultobj;
48484 fail:
48485 {
48486 if (temp3)
48487 delete arg3;
48488 }
48489 return NULL;
48490 }
48491
48492
48493 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48494 PyObject *resultobj = 0;
48495 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48496 wxString *arg2 = 0 ;
48497 int result;
48498 void *argp1 = 0 ;
48499 int res1 = 0 ;
48500 bool temp2 = false ;
48501 PyObject * obj0 = 0 ;
48502 PyObject * obj1 = 0 ;
48503 char * kwnames[] = {
48504 (char *) "self",(char *) "s", NULL
48505 };
48506
48507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48509 if (!SWIG_IsOK(res1)) {
48510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48511 }
48512 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48513 {
48514 arg2 = wxString_in_helper(obj1);
48515 if (arg2 == NULL) SWIG_fail;
48516 temp2 = true;
48517 }
48518 {
48519 PyThreadState* __tstate = wxPyBeginAllowThreads();
48520 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48521 wxPyEndAllowThreads(__tstate);
48522 if (PyErr_Occurred()) SWIG_fail;
48523 }
48524 resultobj = SWIG_From_int(static_cast< int >(result));
48525 {
48526 if (temp2)
48527 delete arg2;
48528 }
48529 return resultobj;
48530 fail:
48531 {
48532 if (temp2)
48533 delete arg2;
48534 }
48535 return NULL;
48536 }
48537
48538
48539 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48540 PyObject *resultobj = 0;
48541 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48542 int arg2 ;
48543 void *argp1 = 0 ;
48544 int res1 = 0 ;
48545 int val2 ;
48546 int ecode2 = 0 ;
48547 PyObject * obj0 = 0 ;
48548 PyObject * obj1 = 0 ;
48549 char * kwnames[] = {
48550 (char *) "self",(char *) "n", NULL
48551 };
48552
48553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48555 if (!SWIG_IsOK(res1)) {
48556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48557 }
48558 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48559 ecode2 = SWIG_AsVal_int(obj1, &val2);
48560 if (!SWIG_IsOK(ecode2)) {
48561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48562 }
48563 arg2 = static_cast< int >(val2);
48564 {
48565 PyThreadState* __tstate = wxPyBeginAllowThreads();
48566 (arg1)->SetSelection(arg2);
48567 wxPyEndAllowThreads(__tstate);
48568 if (PyErr_Occurred()) SWIG_fail;
48569 }
48570 resultobj = SWIG_Py_Void();
48571 return resultobj;
48572 fail:
48573 return NULL;
48574 }
48575
48576
48577 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48578 PyObject *resultobj = 0;
48579 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48580 int result;
48581 void *argp1 = 0 ;
48582 int res1 = 0 ;
48583 PyObject *swig_obj[1] ;
48584
48585 if (!args) SWIG_fail;
48586 swig_obj[0] = args;
48587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48588 if (!SWIG_IsOK(res1)) {
48589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48590 }
48591 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48592 {
48593 PyThreadState* __tstate = wxPyBeginAllowThreads();
48594 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48595 wxPyEndAllowThreads(__tstate);
48596 if (PyErr_Occurred()) SWIG_fail;
48597 }
48598 resultobj = SWIG_From_int(static_cast< int >(result));
48599 return resultobj;
48600 fail:
48601 return NULL;
48602 }
48603
48604
48605 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48606 PyObject *resultobj = 0;
48607 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48608 wxString *arg2 = 0 ;
48609 bool result;
48610 void *argp1 = 0 ;
48611 int res1 = 0 ;
48612 bool temp2 = false ;
48613 PyObject * obj0 = 0 ;
48614 PyObject * obj1 = 0 ;
48615 char * kwnames[] = {
48616 (char *) "self",(char *) "s", NULL
48617 };
48618
48619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48621 if (!SWIG_IsOK(res1)) {
48622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48623 }
48624 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48625 {
48626 arg2 = wxString_in_helper(obj1);
48627 if (arg2 == NULL) SWIG_fail;
48628 temp2 = true;
48629 }
48630 {
48631 PyThreadState* __tstate = wxPyBeginAllowThreads();
48632 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48633 wxPyEndAllowThreads(__tstate);
48634 if (PyErr_Occurred()) SWIG_fail;
48635 }
48636 {
48637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48638 }
48639 {
48640 if (temp2)
48641 delete arg2;
48642 }
48643 return resultobj;
48644 fail:
48645 {
48646 if (temp2)
48647 delete arg2;
48648 }
48649 return NULL;
48650 }
48651
48652
48653 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48654 PyObject *resultobj = 0;
48655 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48656 wxString result;
48657 void *argp1 = 0 ;
48658 int res1 = 0 ;
48659 PyObject *swig_obj[1] ;
48660
48661 if (!args) SWIG_fail;
48662 swig_obj[0] = args;
48663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48664 if (!SWIG_IsOK(res1)) {
48665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48666 }
48667 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48668 {
48669 PyThreadState* __tstate = wxPyBeginAllowThreads();
48670 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48671 wxPyEndAllowThreads(__tstate);
48672 if (PyErr_Occurred()) SWIG_fail;
48673 }
48674 {
48675 #if wxUSE_UNICODE
48676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48677 #else
48678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48679 #endif
48680 }
48681 return resultobj;
48682 fail:
48683 return NULL;
48684 }
48685
48686
48687 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48688 PyObject *resultobj = 0;
48689 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48690 int arg2 ;
48691 void *argp1 = 0 ;
48692 int res1 = 0 ;
48693 int val2 ;
48694 int ecode2 = 0 ;
48695 PyObject * obj0 = 0 ;
48696 PyObject * obj1 = 0 ;
48697 char * kwnames[] = {
48698 (char *) "self",(char *) "n", NULL
48699 };
48700
48701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48703 if (!SWIG_IsOK(res1)) {
48704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48705 }
48706 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48707 ecode2 = SWIG_AsVal_int(obj1, &val2);
48708 if (!SWIG_IsOK(ecode2)) {
48709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48710 }
48711 arg2 = static_cast< int >(val2);
48712 {
48713 PyThreadState* __tstate = wxPyBeginAllowThreads();
48714 (arg1)->Select(arg2);
48715 wxPyEndAllowThreads(__tstate);
48716 if (PyErr_Occurred()) SWIG_fail;
48717 }
48718 resultobj = SWIG_Py_Void();
48719 return resultobj;
48720 fail:
48721 return NULL;
48722 }
48723
48724
48725 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48726 PyObject *obj;
48727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48728 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48729 return SWIG_Py_Void();
48730 }
48731
48732 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48733 PyObject *obj;
48734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48735 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48736 return SWIG_Py_Void();
48737 }
48738
48739 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48740 PyObject *resultobj = 0;
48741 int arg1 = (int) 0 ;
48742 wxSizerFlags *result = 0 ;
48743 int val1 ;
48744 int ecode1 = 0 ;
48745 PyObject * obj0 = 0 ;
48746 char * kwnames[] = {
48747 (char *) "proportion", NULL
48748 };
48749
48750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
48751 if (obj0) {
48752 ecode1 = SWIG_AsVal_int(obj0, &val1);
48753 if (!SWIG_IsOK(ecode1)) {
48754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
48755 }
48756 arg1 = static_cast< int >(val1);
48757 }
48758 {
48759 PyThreadState* __tstate = wxPyBeginAllowThreads();
48760 result = (wxSizerFlags *)new wxSizerFlags(arg1);
48761 wxPyEndAllowThreads(__tstate);
48762 if (PyErr_Occurred()) SWIG_fail;
48763 }
48764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
48765 return resultobj;
48766 fail:
48767 return NULL;
48768 }
48769
48770
48771 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48772 PyObject *resultobj = 0;
48773 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48774 void *argp1 = 0 ;
48775 int res1 = 0 ;
48776 PyObject *swig_obj[1] ;
48777
48778 if (!args) SWIG_fail;
48779 swig_obj[0] = args;
48780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48783 }
48784 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48785 {
48786 PyThreadState* __tstate = wxPyBeginAllowThreads();
48787 delete arg1;
48788
48789 wxPyEndAllowThreads(__tstate);
48790 if (PyErr_Occurred()) SWIG_fail;
48791 }
48792 resultobj = SWIG_Py_Void();
48793 return resultobj;
48794 fail:
48795 return NULL;
48796 }
48797
48798
48799 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48800 PyObject *resultobj = 0;
48801 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48802 int arg2 ;
48803 wxSizerFlags *result = 0 ;
48804 void *argp1 = 0 ;
48805 int res1 = 0 ;
48806 int val2 ;
48807 int ecode2 = 0 ;
48808 PyObject * obj0 = 0 ;
48809 PyObject * obj1 = 0 ;
48810 char * kwnames[] = {
48811 (char *) "self",(char *) "proportion", NULL
48812 };
48813
48814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
48815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48816 if (!SWIG_IsOK(res1)) {
48817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48818 }
48819 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48820 ecode2 = SWIG_AsVal_int(obj1, &val2);
48821 if (!SWIG_IsOK(ecode2)) {
48822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
48823 }
48824 arg2 = static_cast< int >(val2);
48825 {
48826 PyThreadState* __tstate = wxPyBeginAllowThreads();
48827 {
48828 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
48829 result = (wxSizerFlags *) &_result_ref;
48830 }
48831 wxPyEndAllowThreads(__tstate);
48832 if (PyErr_Occurred()) SWIG_fail;
48833 }
48834 {
48835 resultobj = obj0; Py_INCREF(resultobj);
48836 }
48837 return resultobj;
48838 fail:
48839 return NULL;
48840 }
48841
48842
48843 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48844 PyObject *resultobj = 0;
48845 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48846 int arg2 ;
48847 wxSizerFlags *result = 0 ;
48848 void *argp1 = 0 ;
48849 int res1 = 0 ;
48850 int val2 ;
48851 int ecode2 = 0 ;
48852 PyObject * obj0 = 0 ;
48853 PyObject * obj1 = 0 ;
48854 char * kwnames[] = {
48855 (char *) "self",(char *) "alignment", NULL
48856 };
48857
48858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
48859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48860 if (!SWIG_IsOK(res1)) {
48861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48862 }
48863 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48864 ecode2 = SWIG_AsVal_int(obj1, &val2);
48865 if (!SWIG_IsOK(ecode2)) {
48866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
48867 }
48868 arg2 = static_cast< int >(val2);
48869 {
48870 PyThreadState* __tstate = wxPyBeginAllowThreads();
48871 {
48872 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
48873 result = (wxSizerFlags *) &_result_ref;
48874 }
48875 wxPyEndAllowThreads(__tstate);
48876 if (PyErr_Occurred()) SWIG_fail;
48877 }
48878 {
48879 resultobj = obj0; Py_INCREF(resultobj);
48880 }
48881 return resultobj;
48882 fail:
48883 return NULL;
48884 }
48885
48886
48887 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48888 PyObject *resultobj = 0;
48889 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48890 wxSizerFlags *result = 0 ;
48891 void *argp1 = 0 ;
48892 int res1 = 0 ;
48893 PyObject *swig_obj[1] ;
48894
48895 if (!args) SWIG_fail;
48896 swig_obj[0] = args;
48897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48898 if (!SWIG_IsOK(res1)) {
48899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48900 }
48901 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48902 {
48903 PyThreadState* __tstate = wxPyBeginAllowThreads();
48904 {
48905 wxSizerFlags &_result_ref = (arg1)->Expand();
48906 result = (wxSizerFlags *) &_result_ref;
48907 }
48908 wxPyEndAllowThreads(__tstate);
48909 if (PyErr_Occurred()) SWIG_fail;
48910 }
48911 {
48912 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48913 }
48914 return resultobj;
48915 fail:
48916 return NULL;
48917 }
48918
48919
48920 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48921 PyObject *resultobj = 0;
48922 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48923 wxSizerFlags *result = 0 ;
48924 void *argp1 = 0 ;
48925 int res1 = 0 ;
48926 PyObject *swig_obj[1] ;
48927
48928 if (!args) SWIG_fail;
48929 swig_obj[0] = args;
48930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48931 if (!SWIG_IsOK(res1)) {
48932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48933 }
48934 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48935 {
48936 PyThreadState* __tstate = wxPyBeginAllowThreads();
48937 {
48938 wxSizerFlags &_result_ref = (arg1)->Centre();
48939 result = (wxSizerFlags *) &_result_ref;
48940 }
48941 wxPyEndAllowThreads(__tstate);
48942 if (PyErr_Occurred()) SWIG_fail;
48943 }
48944 {
48945 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48946 }
48947 return resultobj;
48948 fail:
48949 return NULL;
48950 }
48951
48952
48953 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48954 PyObject *resultobj = 0;
48955 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48956 wxSizerFlags *result = 0 ;
48957 void *argp1 = 0 ;
48958 int res1 = 0 ;
48959 PyObject *swig_obj[1] ;
48960
48961 if (!args) SWIG_fail;
48962 swig_obj[0] = args;
48963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48964 if (!SWIG_IsOK(res1)) {
48965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48966 }
48967 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48968 {
48969 PyThreadState* __tstate = wxPyBeginAllowThreads();
48970 {
48971 wxSizerFlags &_result_ref = (arg1)->Center();
48972 result = (wxSizerFlags *) &_result_ref;
48973 }
48974 wxPyEndAllowThreads(__tstate);
48975 if (PyErr_Occurred()) SWIG_fail;
48976 }
48977 {
48978 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48979 }
48980 return resultobj;
48981 fail:
48982 return NULL;
48983 }
48984
48985
48986 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48987 PyObject *resultobj = 0;
48988 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48989 wxSizerFlags *result = 0 ;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 PyObject *swig_obj[1] ;
48993
48994 if (!args) SWIG_fail;
48995 swig_obj[0] = args;
48996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48997 if (!SWIG_IsOK(res1)) {
48998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48999 }
49000 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49001 {
49002 PyThreadState* __tstate = wxPyBeginAllowThreads();
49003 {
49004 wxSizerFlags &_result_ref = (arg1)->Left();
49005 result = (wxSizerFlags *) &_result_ref;
49006 }
49007 wxPyEndAllowThreads(__tstate);
49008 if (PyErr_Occurred()) SWIG_fail;
49009 }
49010 {
49011 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49012 }
49013 return resultobj;
49014 fail:
49015 return NULL;
49016 }
49017
49018
49019 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49020 PyObject *resultobj = 0;
49021 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49022 wxSizerFlags *result = 0 ;
49023 void *argp1 = 0 ;
49024 int res1 = 0 ;
49025 PyObject *swig_obj[1] ;
49026
49027 if (!args) SWIG_fail;
49028 swig_obj[0] = args;
49029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49030 if (!SWIG_IsOK(res1)) {
49031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49032 }
49033 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49034 {
49035 PyThreadState* __tstate = wxPyBeginAllowThreads();
49036 {
49037 wxSizerFlags &_result_ref = (arg1)->Right();
49038 result = (wxSizerFlags *) &_result_ref;
49039 }
49040 wxPyEndAllowThreads(__tstate);
49041 if (PyErr_Occurred()) SWIG_fail;
49042 }
49043 {
49044 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49045 }
49046 return resultobj;
49047 fail:
49048 return NULL;
49049 }
49050
49051
49052 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49053 PyObject *resultobj = 0;
49054 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49055 wxSizerFlags *result = 0 ;
49056 void *argp1 = 0 ;
49057 int res1 = 0 ;
49058 PyObject *swig_obj[1] ;
49059
49060 if (!args) SWIG_fail;
49061 swig_obj[0] = args;
49062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49063 if (!SWIG_IsOK(res1)) {
49064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49065 }
49066 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49067 {
49068 PyThreadState* __tstate = wxPyBeginAllowThreads();
49069 {
49070 wxSizerFlags &_result_ref = (arg1)->Top();
49071 result = (wxSizerFlags *) &_result_ref;
49072 }
49073 wxPyEndAllowThreads(__tstate);
49074 if (PyErr_Occurred()) SWIG_fail;
49075 }
49076 {
49077 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49078 }
49079 return resultobj;
49080 fail:
49081 return NULL;
49082 }
49083
49084
49085 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49086 PyObject *resultobj = 0;
49087 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49088 wxSizerFlags *result = 0 ;
49089 void *argp1 = 0 ;
49090 int res1 = 0 ;
49091 PyObject *swig_obj[1] ;
49092
49093 if (!args) SWIG_fail;
49094 swig_obj[0] = args;
49095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49096 if (!SWIG_IsOK(res1)) {
49097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49098 }
49099 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49100 {
49101 PyThreadState* __tstate = wxPyBeginAllowThreads();
49102 {
49103 wxSizerFlags &_result_ref = (arg1)->Bottom();
49104 result = (wxSizerFlags *) &_result_ref;
49105 }
49106 wxPyEndAllowThreads(__tstate);
49107 if (PyErr_Occurred()) SWIG_fail;
49108 }
49109 {
49110 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49111 }
49112 return resultobj;
49113 fail:
49114 return NULL;
49115 }
49116
49117
49118 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49119 PyObject *resultobj = 0;
49120 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49121 wxSizerFlags *result = 0 ;
49122 void *argp1 = 0 ;
49123 int res1 = 0 ;
49124 PyObject *swig_obj[1] ;
49125
49126 if (!args) SWIG_fail;
49127 swig_obj[0] = args;
49128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49129 if (!SWIG_IsOK(res1)) {
49130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49131 }
49132 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49133 {
49134 PyThreadState* __tstate = wxPyBeginAllowThreads();
49135 {
49136 wxSizerFlags &_result_ref = (arg1)->Shaped();
49137 result = (wxSizerFlags *) &_result_ref;
49138 }
49139 wxPyEndAllowThreads(__tstate);
49140 if (PyErr_Occurred()) SWIG_fail;
49141 }
49142 {
49143 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49144 }
49145 return resultobj;
49146 fail:
49147 return NULL;
49148 }
49149
49150
49151 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49152 PyObject *resultobj = 0;
49153 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49154 wxSizerFlags *result = 0 ;
49155 void *argp1 = 0 ;
49156 int res1 = 0 ;
49157 PyObject *swig_obj[1] ;
49158
49159 if (!args) SWIG_fail;
49160 swig_obj[0] = args;
49161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49162 if (!SWIG_IsOK(res1)) {
49163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49164 }
49165 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49166 {
49167 PyThreadState* __tstate = wxPyBeginAllowThreads();
49168 {
49169 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49170 result = (wxSizerFlags *) &_result_ref;
49171 }
49172 wxPyEndAllowThreads(__tstate);
49173 if (PyErr_Occurred()) SWIG_fail;
49174 }
49175 {
49176 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49177 }
49178 return resultobj;
49179 fail:
49180 return NULL;
49181 }
49182
49183
49184 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49185 PyObject *resultobj = 0;
49186 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49187 int arg2 = (int) wxALL ;
49188 int arg3 = (int) -1 ;
49189 wxSizerFlags *result = 0 ;
49190 void *argp1 = 0 ;
49191 int res1 = 0 ;
49192 int val2 ;
49193 int ecode2 = 0 ;
49194 int val3 ;
49195 int ecode3 = 0 ;
49196 PyObject * obj0 = 0 ;
49197 PyObject * obj1 = 0 ;
49198 PyObject * obj2 = 0 ;
49199 char * kwnames[] = {
49200 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49201 };
49202
49203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49205 if (!SWIG_IsOK(res1)) {
49206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49207 }
49208 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49209 if (obj1) {
49210 ecode2 = SWIG_AsVal_int(obj1, &val2);
49211 if (!SWIG_IsOK(ecode2)) {
49212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49213 }
49214 arg2 = static_cast< int >(val2);
49215 }
49216 if (obj2) {
49217 ecode3 = SWIG_AsVal_int(obj2, &val3);
49218 if (!SWIG_IsOK(ecode3)) {
49219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49220 }
49221 arg3 = static_cast< int >(val3);
49222 }
49223 {
49224 PyThreadState* __tstate = wxPyBeginAllowThreads();
49225 {
49226 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49227 result = (wxSizerFlags *) &_result_ref;
49228 }
49229 wxPyEndAllowThreads(__tstate);
49230 if (PyErr_Occurred()) SWIG_fail;
49231 }
49232 {
49233 resultobj = obj0; Py_INCREF(resultobj);
49234 }
49235 return resultobj;
49236 fail:
49237 return NULL;
49238 }
49239
49240
49241 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49242 PyObject *resultobj = 0;
49243 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49244 int arg2 = (int) wxALL ;
49245 wxSizerFlags *result = 0 ;
49246 void *argp1 = 0 ;
49247 int res1 = 0 ;
49248 int val2 ;
49249 int ecode2 = 0 ;
49250 PyObject * obj0 = 0 ;
49251 PyObject * obj1 = 0 ;
49252 char * kwnames[] = {
49253 (char *) "self",(char *) "direction", NULL
49254 };
49255
49256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49258 if (!SWIG_IsOK(res1)) {
49259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49260 }
49261 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49262 if (obj1) {
49263 ecode2 = SWIG_AsVal_int(obj1, &val2);
49264 if (!SWIG_IsOK(ecode2)) {
49265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49266 }
49267 arg2 = static_cast< int >(val2);
49268 }
49269 {
49270 PyThreadState* __tstate = wxPyBeginAllowThreads();
49271 {
49272 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49273 result = (wxSizerFlags *) &_result_ref;
49274 }
49275 wxPyEndAllowThreads(__tstate);
49276 if (PyErr_Occurred()) SWIG_fail;
49277 }
49278 {
49279 resultobj = obj0; Py_INCREF(resultobj);
49280 }
49281 return resultobj;
49282 fail:
49283 return NULL;
49284 }
49285
49286
49287 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49288 PyObject *resultobj = 0;
49289 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49290 int arg2 = (int) wxALL ;
49291 wxSizerFlags *result = 0 ;
49292 void *argp1 = 0 ;
49293 int res1 = 0 ;
49294 int val2 ;
49295 int ecode2 = 0 ;
49296 PyObject * obj0 = 0 ;
49297 PyObject * obj1 = 0 ;
49298 char * kwnames[] = {
49299 (char *) "self",(char *) "direction", NULL
49300 };
49301
49302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49304 if (!SWIG_IsOK(res1)) {
49305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49306 }
49307 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49308 if (obj1) {
49309 ecode2 = SWIG_AsVal_int(obj1, &val2);
49310 if (!SWIG_IsOK(ecode2)) {
49311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49312 }
49313 arg2 = static_cast< int >(val2);
49314 }
49315 {
49316 PyThreadState* __tstate = wxPyBeginAllowThreads();
49317 {
49318 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49319 result = (wxSizerFlags *) &_result_ref;
49320 }
49321 wxPyEndAllowThreads(__tstate);
49322 if (PyErr_Occurred()) SWIG_fail;
49323 }
49324 {
49325 resultobj = obj0; Py_INCREF(resultobj);
49326 }
49327 return resultobj;
49328 fail:
49329 return NULL;
49330 }
49331
49332
49333 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49334 PyObject *resultobj = 0;
49335 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49336 wxSizerFlags *result = 0 ;
49337 void *argp1 = 0 ;
49338 int res1 = 0 ;
49339 PyObject *swig_obj[1] ;
49340
49341 if (!args) SWIG_fail;
49342 swig_obj[0] = args;
49343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49344 if (!SWIG_IsOK(res1)) {
49345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49346 }
49347 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49348 {
49349 PyThreadState* __tstate = wxPyBeginAllowThreads();
49350 {
49351 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49352 result = (wxSizerFlags *) &_result_ref;
49353 }
49354 wxPyEndAllowThreads(__tstate);
49355 if (PyErr_Occurred()) SWIG_fail;
49356 }
49357 {
49358 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49359 }
49360 return resultobj;
49361 fail:
49362 return NULL;
49363 }
49364
49365
49366 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49367 PyObject *resultobj = 0;
49368 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49369 wxSizerFlags *result = 0 ;
49370 void *argp1 = 0 ;
49371 int res1 = 0 ;
49372 PyObject *swig_obj[1] ;
49373
49374 if (!args) SWIG_fail;
49375 swig_obj[0] = args;
49376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49377 if (!SWIG_IsOK(res1)) {
49378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49379 }
49380 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49381 {
49382 PyThreadState* __tstate = wxPyBeginAllowThreads();
49383 {
49384 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49385 result = (wxSizerFlags *) &_result_ref;
49386 }
49387 wxPyEndAllowThreads(__tstate);
49388 if (PyErr_Occurred()) SWIG_fail;
49389 }
49390 {
49391 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49392 }
49393 return resultobj;
49394 fail:
49395 return NULL;
49396 }
49397
49398
49399 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49400 PyObject *resultobj = 0;
49401 int result;
49402
49403 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49404 {
49405 PyThreadState* __tstate = wxPyBeginAllowThreads();
49406 result = (int)wxSizerFlags::GetDefaultBorder();
49407 wxPyEndAllowThreads(__tstate);
49408 if (PyErr_Occurred()) SWIG_fail;
49409 }
49410 resultobj = SWIG_From_int(static_cast< int >(result));
49411 return resultobj;
49412 fail:
49413 return NULL;
49414 }
49415
49416
49417 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49418 PyObject *resultobj = 0;
49419 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49420 int result;
49421 void *argp1 = 0 ;
49422 int res1 = 0 ;
49423 PyObject *swig_obj[1] ;
49424
49425 if (!args) SWIG_fail;
49426 swig_obj[0] = args;
49427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49428 if (!SWIG_IsOK(res1)) {
49429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49430 }
49431 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49432 {
49433 PyThreadState* __tstate = wxPyBeginAllowThreads();
49434 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49435 wxPyEndAllowThreads(__tstate);
49436 if (PyErr_Occurred()) SWIG_fail;
49437 }
49438 resultobj = SWIG_From_int(static_cast< int >(result));
49439 return resultobj;
49440 fail:
49441 return NULL;
49442 }
49443
49444
49445 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49446 PyObject *resultobj = 0;
49447 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49448 int result;
49449 void *argp1 = 0 ;
49450 int res1 = 0 ;
49451 PyObject *swig_obj[1] ;
49452
49453 if (!args) SWIG_fail;
49454 swig_obj[0] = args;
49455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49456 if (!SWIG_IsOK(res1)) {
49457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49458 }
49459 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49460 {
49461 PyThreadState* __tstate = wxPyBeginAllowThreads();
49462 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
49463 wxPyEndAllowThreads(__tstate);
49464 if (PyErr_Occurred()) SWIG_fail;
49465 }
49466 resultobj = SWIG_From_int(static_cast< int >(result));
49467 return resultobj;
49468 fail:
49469 return NULL;
49470 }
49471
49472
49473 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49474 PyObject *resultobj = 0;
49475 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49476 int result;
49477 void *argp1 = 0 ;
49478 int res1 = 0 ;
49479 PyObject *swig_obj[1] ;
49480
49481 if (!args) SWIG_fail;
49482 swig_obj[0] = args;
49483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49484 if (!SWIG_IsOK(res1)) {
49485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49486 }
49487 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49488 {
49489 PyThreadState* __tstate = wxPyBeginAllowThreads();
49490 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
49491 wxPyEndAllowThreads(__tstate);
49492 if (PyErr_Occurred()) SWIG_fail;
49493 }
49494 resultobj = SWIG_From_int(static_cast< int >(result));
49495 return resultobj;
49496 fail:
49497 return NULL;
49498 }
49499
49500
49501 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49502 PyObject *obj;
49503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49504 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
49505 return SWIG_Py_Void();
49506 }
49507
49508 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49509 return SWIG_Python_InitShadowInstance(args);
49510 }
49511
49512 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49513 PyObject *resultobj = 0;
49514 wxSizerItem *result = 0 ;
49515
49516 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
49517 {
49518 PyThreadState* __tstate = wxPyBeginAllowThreads();
49519 result = (wxSizerItem *)new wxSizerItem();
49520 wxPyEndAllowThreads(__tstate);
49521 if (PyErr_Occurred()) SWIG_fail;
49522 }
49523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
49524 return resultobj;
49525 fail:
49526 return NULL;
49527 }
49528
49529
49530 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49531 PyObject *resultobj = 0;
49532 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49533 void *argp1 = 0 ;
49534 int res1 = 0 ;
49535 PyObject *swig_obj[1] ;
49536
49537 if (!args) SWIG_fail;
49538 swig_obj[0] = args;
49539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
49540 if (!SWIG_IsOK(res1)) {
49541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49542 }
49543 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49544 {
49545 PyThreadState* __tstate = wxPyBeginAllowThreads();
49546 delete arg1;
49547
49548 wxPyEndAllowThreads(__tstate);
49549 if (PyErr_Occurred()) SWIG_fail;
49550 }
49551 resultobj = SWIG_Py_Void();
49552 return resultobj;
49553 fail:
49554 return NULL;
49555 }
49556
49557
49558 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49559 PyObject *resultobj = 0;
49560 wxWindow *arg1 = (wxWindow *) 0 ;
49561 int arg2 ;
49562 int arg3 ;
49563 int arg4 ;
49564 PyObject *arg5 = (PyObject *) NULL ;
49565 wxSizerItem *result = 0 ;
49566 void *argp1 = 0 ;
49567 int res1 = 0 ;
49568 int val2 ;
49569 int ecode2 = 0 ;
49570 int val3 ;
49571 int ecode3 = 0 ;
49572 int val4 ;
49573 int ecode4 = 0 ;
49574 PyObject * obj0 = 0 ;
49575 PyObject * obj1 = 0 ;
49576 PyObject * obj2 = 0 ;
49577 PyObject * obj3 = 0 ;
49578 PyObject * obj4 = 0 ;
49579 char * kwnames[] = {
49580 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49581 };
49582
49583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49585 if (!SWIG_IsOK(res1)) {
49586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49587 }
49588 arg1 = reinterpret_cast< wxWindow * >(argp1);
49589 ecode2 = SWIG_AsVal_int(obj1, &val2);
49590 if (!SWIG_IsOK(ecode2)) {
49591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
49592 }
49593 arg2 = static_cast< int >(val2);
49594 ecode3 = SWIG_AsVal_int(obj2, &val3);
49595 if (!SWIG_IsOK(ecode3)) {
49596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
49597 }
49598 arg3 = static_cast< int >(val3);
49599 ecode4 = SWIG_AsVal_int(obj3, &val4);
49600 if (!SWIG_IsOK(ecode4)) {
49601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49602 }
49603 arg4 = static_cast< int >(val4);
49604 if (obj4) {
49605 arg5 = obj4;
49606 }
49607 {
49608 PyThreadState* __tstate = wxPyBeginAllowThreads();
49609 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49610 wxPyEndAllowThreads(__tstate);
49611 if (PyErr_Occurred()) SWIG_fail;
49612 }
49613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49614 return resultobj;
49615 fail:
49616 return NULL;
49617 }
49618
49619
49620 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49621 PyObject *resultobj = 0;
49622 int arg1 ;
49623 int arg2 ;
49624 int arg3 ;
49625 int arg4 ;
49626 int arg5 ;
49627 PyObject *arg6 = (PyObject *) NULL ;
49628 wxSizerItem *result = 0 ;
49629 int val1 ;
49630 int ecode1 = 0 ;
49631 int val2 ;
49632 int ecode2 = 0 ;
49633 int val3 ;
49634 int ecode3 = 0 ;
49635 int val4 ;
49636 int ecode4 = 0 ;
49637 int val5 ;
49638 int ecode5 = 0 ;
49639 PyObject * obj0 = 0 ;
49640 PyObject * obj1 = 0 ;
49641 PyObject * obj2 = 0 ;
49642 PyObject * obj3 = 0 ;
49643 PyObject * obj4 = 0 ;
49644 PyObject * obj5 = 0 ;
49645 char * kwnames[] = {
49646 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49647 };
49648
49649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49650 ecode1 = SWIG_AsVal_int(obj0, &val1);
49651 if (!SWIG_IsOK(ecode1)) {
49652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49653 }
49654 arg1 = static_cast< int >(val1);
49655 ecode2 = SWIG_AsVal_int(obj1, &val2);
49656 if (!SWIG_IsOK(ecode2)) {
49657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49658 }
49659 arg2 = static_cast< int >(val2);
49660 ecode3 = SWIG_AsVal_int(obj2, &val3);
49661 if (!SWIG_IsOK(ecode3)) {
49662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
49663 }
49664 arg3 = static_cast< int >(val3);
49665 ecode4 = SWIG_AsVal_int(obj3, &val4);
49666 if (!SWIG_IsOK(ecode4)) {
49667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
49668 }
49669 arg4 = static_cast< int >(val4);
49670 ecode5 = SWIG_AsVal_int(obj4, &val5);
49671 if (!SWIG_IsOK(ecode5)) {
49672 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49673 }
49674 arg5 = static_cast< int >(val5);
49675 if (obj5) {
49676 arg6 = obj5;
49677 }
49678 {
49679 PyThreadState* __tstate = wxPyBeginAllowThreads();
49680 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
49681 wxPyEndAllowThreads(__tstate);
49682 if (PyErr_Occurred()) SWIG_fail;
49683 }
49684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49685 return resultobj;
49686 fail:
49687 return NULL;
49688 }
49689
49690
49691 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49692 PyObject *resultobj = 0;
49693 wxSizer *arg1 = (wxSizer *) 0 ;
49694 int arg2 ;
49695 int arg3 ;
49696 int arg4 ;
49697 PyObject *arg5 = (PyObject *) NULL ;
49698 wxSizerItem *result = 0 ;
49699 int res1 = 0 ;
49700 int val2 ;
49701 int ecode2 = 0 ;
49702 int val3 ;
49703 int ecode3 = 0 ;
49704 int val4 ;
49705 int ecode4 = 0 ;
49706 PyObject * obj0 = 0 ;
49707 PyObject * obj1 = 0 ;
49708 PyObject * obj2 = 0 ;
49709 PyObject * obj3 = 0 ;
49710 PyObject * obj4 = 0 ;
49711 char * kwnames[] = {
49712 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49713 };
49714
49715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49716 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49717 if (!SWIG_IsOK(res1)) {
49718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49719 }
49720 ecode2 = SWIG_AsVal_int(obj1, &val2);
49721 if (!SWIG_IsOK(ecode2)) {
49722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
49723 }
49724 arg2 = static_cast< int >(val2);
49725 ecode3 = SWIG_AsVal_int(obj2, &val3);
49726 if (!SWIG_IsOK(ecode3)) {
49727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
49728 }
49729 arg3 = static_cast< int >(val3);
49730 ecode4 = SWIG_AsVal_int(obj3, &val4);
49731 if (!SWIG_IsOK(ecode4)) {
49732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49733 }
49734 arg4 = static_cast< int >(val4);
49735 if (obj4) {
49736 arg5 = obj4;
49737 }
49738 {
49739 PyThreadState* __tstate = wxPyBeginAllowThreads();
49740 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49741 wxPyEndAllowThreads(__tstate);
49742 if (PyErr_Occurred()) SWIG_fail;
49743 }
49744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49745 return resultobj;
49746 fail:
49747 return NULL;
49748 }
49749
49750
49751 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49752 PyObject *resultobj = 0;
49753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49754 void *argp1 = 0 ;
49755 int res1 = 0 ;
49756 PyObject *swig_obj[1] ;
49757
49758 if (!args) SWIG_fail;
49759 swig_obj[0] = args;
49760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49761 if (!SWIG_IsOK(res1)) {
49762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49763 }
49764 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49765 {
49766 PyThreadState* __tstate = wxPyBeginAllowThreads();
49767 (arg1)->DeleteWindows();
49768 wxPyEndAllowThreads(__tstate);
49769 if (PyErr_Occurred()) SWIG_fail;
49770 }
49771 resultobj = SWIG_Py_Void();
49772 return resultobj;
49773 fail:
49774 return NULL;
49775 }
49776
49777
49778 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49779 PyObject *resultobj = 0;
49780 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49781 void *argp1 = 0 ;
49782 int res1 = 0 ;
49783 PyObject *swig_obj[1] ;
49784
49785 if (!args) SWIG_fail;
49786 swig_obj[0] = args;
49787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49788 if (!SWIG_IsOK(res1)) {
49789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49790 }
49791 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49792 {
49793 PyThreadState* __tstate = wxPyBeginAllowThreads();
49794 (arg1)->DetachSizer();
49795 wxPyEndAllowThreads(__tstate);
49796 if (PyErr_Occurred()) SWIG_fail;
49797 }
49798 resultobj = SWIG_Py_Void();
49799 return resultobj;
49800 fail:
49801 return NULL;
49802 }
49803
49804
49805 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49806 PyObject *resultobj = 0;
49807 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49808 wxSize result;
49809 void *argp1 = 0 ;
49810 int res1 = 0 ;
49811 PyObject *swig_obj[1] ;
49812
49813 if (!args) SWIG_fail;
49814 swig_obj[0] = args;
49815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49816 if (!SWIG_IsOK(res1)) {
49817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49818 }
49819 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49820 {
49821 PyThreadState* __tstate = wxPyBeginAllowThreads();
49822 result = (arg1)->GetSize();
49823 wxPyEndAllowThreads(__tstate);
49824 if (PyErr_Occurred()) SWIG_fail;
49825 }
49826 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49827 return resultobj;
49828 fail:
49829 return NULL;
49830 }
49831
49832
49833 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49834 PyObject *resultobj = 0;
49835 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49836 wxSize result;
49837 void *argp1 = 0 ;
49838 int res1 = 0 ;
49839 PyObject *swig_obj[1] ;
49840
49841 if (!args) SWIG_fail;
49842 swig_obj[0] = args;
49843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49844 if (!SWIG_IsOK(res1)) {
49845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49846 }
49847 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49848 {
49849 PyThreadState* __tstate = wxPyBeginAllowThreads();
49850 result = (arg1)->CalcMin();
49851 wxPyEndAllowThreads(__tstate);
49852 if (PyErr_Occurred()) SWIG_fail;
49853 }
49854 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49855 return resultobj;
49856 fail:
49857 return NULL;
49858 }
49859
49860
49861 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49862 PyObject *resultobj = 0;
49863 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49864 wxPoint *arg2 = 0 ;
49865 wxSize *arg3 = 0 ;
49866 void *argp1 = 0 ;
49867 int res1 = 0 ;
49868 wxPoint temp2 ;
49869 wxSize temp3 ;
49870 PyObject * obj0 = 0 ;
49871 PyObject * obj1 = 0 ;
49872 PyObject * obj2 = 0 ;
49873 char * kwnames[] = {
49874 (char *) "self",(char *) "pos",(char *) "size", NULL
49875 };
49876
49877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49879 if (!SWIG_IsOK(res1)) {
49880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49881 }
49882 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49883 {
49884 arg2 = &temp2;
49885 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
49886 }
49887 {
49888 arg3 = &temp3;
49889 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
49890 }
49891 {
49892 PyThreadState* __tstate = wxPyBeginAllowThreads();
49893 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
49894 wxPyEndAllowThreads(__tstate);
49895 if (PyErr_Occurred()) SWIG_fail;
49896 }
49897 resultobj = SWIG_Py_Void();
49898 return resultobj;
49899 fail:
49900 return NULL;
49901 }
49902
49903
49904 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49905 PyObject *resultobj = 0;
49906 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49907 wxSize result;
49908 void *argp1 = 0 ;
49909 int res1 = 0 ;
49910 PyObject *swig_obj[1] ;
49911
49912 if (!args) SWIG_fail;
49913 swig_obj[0] = args;
49914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49915 if (!SWIG_IsOK(res1)) {
49916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49917 }
49918 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49919 {
49920 PyThreadState* __tstate = wxPyBeginAllowThreads();
49921 result = (arg1)->GetMinSize();
49922 wxPyEndAllowThreads(__tstate);
49923 if (PyErr_Occurred()) SWIG_fail;
49924 }
49925 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49926 return resultobj;
49927 fail:
49928 return NULL;
49929 }
49930
49931
49932 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49933 PyObject *resultobj = 0;
49934 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49935 wxSize result;
49936 void *argp1 = 0 ;
49937 int res1 = 0 ;
49938 PyObject *swig_obj[1] ;
49939
49940 if (!args) SWIG_fail;
49941 swig_obj[0] = args;
49942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49943 if (!SWIG_IsOK(res1)) {
49944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
49945 }
49946 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49947 {
49948 PyThreadState* __tstate = wxPyBeginAllowThreads();
49949 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
49950 wxPyEndAllowThreads(__tstate);
49951 if (PyErr_Occurred()) SWIG_fail;
49952 }
49953 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49954 return resultobj;
49955 fail:
49956 return NULL;
49957 }
49958
49959
49960 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49961 PyObject *resultobj = 0;
49962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49963 int arg2 ;
49964 int arg3 ;
49965 void *argp1 = 0 ;
49966 int res1 = 0 ;
49967 int val2 ;
49968 int ecode2 = 0 ;
49969 int val3 ;
49970 int ecode3 = 0 ;
49971 PyObject * obj0 = 0 ;
49972 PyObject * obj1 = 0 ;
49973 PyObject * obj2 = 0 ;
49974 char * kwnames[] = {
49975 (char *) "self",(char *) "x",(char *) "y", NULL
49976 };
49977
49978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49980 if (!SWIG_IsOK(res1)) {
49981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49982 }
49983 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49984 ecode2 = SWIG_AsVal_int(obj1, &val2);
49985 if (!SWIG_IsOK(ecode2)) {
49986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
49987 }
49988 arg2 = static_cast< int >(val2);
49989 ecode3 = SWIG_AsVal_int(obj2, &val3);
49990 if (!SWIG_IsOK(ecode3)) {
49991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
49992 }
49993 arg3 = static_cast< int >(val3);
49994 {
49995 PyThreadState* __tstate = wxPyBeginAllowThreads();
49996 (arg1)->SetInitSize(arg2,arg3);
49997 wxPyEndAllowThreads(__tstate);
49998 if (PyErr_Occurred()) SWIG_fail;
49999 }
50000 resultobj = SWIG_Py_Void();
50001 return resultobj;
50002 fail:
50003 return NULL;
50004 }
50005
50006
50007 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50008 PyObject *resultobj = 0;
50009 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50010 int arg2 ;
50011 int arg3 ;
50012 void *argp1 = 0 ;
50013 int res1 = 0 ;
50014 int val2 ;
50015 int ecode2 = 0 ;
50016 int val3 ;
50017 int ecode3 = 0 ;
50018 PyObject * obj0 = 0 ;
50019 PyObject * obj1 = 0 ;
50020 PyObject * obj2 = 0 ;
50021 char * kwnames[] = {
50022 (char *) "self",(char *) "width",(char *) "height", NULL
50023 };
50024
50025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50027 if (!SWIG_IsOK(res1)) {
50028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50029 }
50030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50031 ecode2 = SWIG_AsVal_int(obj1, &val2);
50032 if (!SWIG_IsOK(ecode2)) {
50033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50034 }
50035 arg2 = static_cast< int >(val2);
50036 ecode3 = SWIG_AsVal_int(obj2, &val3);
50037 if (!SWIG_IsOK(ecode3)) {
50038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50039 }
50040 arg3 = static_cast< int >(val3);
50041 {
50042 PyThreadState* __tstate = wxPyBeginAllowThreads();
50043 (arg1)->SetRatio(arg2,arg3);
50044 wxPyEndAllowThreads(__tstate);
50045 if (PyErr_Occurred()) SWIG_fail;
50046 }
50047 resultobj = SWIG_Py_Void();
50048 return resultobj;
50049 fail:
50050 return NULL;
50051 }
50052
50053
50054 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50055 PyObject *resultobj = 0;
50056 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50057 wxSize *arg2 = 0 ;
50058 void *argp1 = 0 ;
50059 int res1 = 0 ;
50060 wxSize temp2 ;
50061 PyObject * obj0 = 0 ;
50062 PyObject * obj1 = 0 ;
50063 char * kwnames[] = {
50064 (char *) "self",(char *) "size", NULL
50065 };
50066
50067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50069 if (!SWIG_IsOK(res1)) {
50070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50071 }
50072 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50073 {
50074 arg2 = &temp2;
50075 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50076 }
50077 {
50078 PyThreadState* __tstate = wxPyBeginAllowThreads();
50079 (arg1)->SetRatio((wxSize const &)*arg2);
50080 wxPyEndAllowThreads(__tstate);
50081 if (PyErr_Occurred()) SWIG_fail;
50082 }
50083 resultobj = SWIG_Py_Void();
50084 return resultobj;
50085 fail:
50086 return NULL;
50087 }
50088
50089
50090 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50091 PyObject *resultobj = 0;
50092 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50093 float arg2 ;
50094 void *argp1 = 0 ;
50095 int res1 = 0 ;
50096 float val2 ;
50097 int ecode2 = 0 ;
50098 PyObject * obj0 = 0 ;
50099 PyObject * obj1 = 0 ;
50100 char * kwnames[] = {
50101 (char *) "self",(char *) "ratio", NULL
50102 };
50103
50104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50106 if (!SWIG_IsOK(res1)) {
50107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50108 }
50109 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50110 ecode2 = SWIG_AsVal_float(obj1, &val2);
50111 if (!SWIG_IsOK(ecode2)) {
50112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50113 }
50114 arg2 = static_cast< float >(val2);
50115 {
50116 PyThreadState* __tstate = wxPyBeginAllowThreads();
50117 (arg1)->SetRatio(arg2);
50118 wxPyEndAllowThreads(__tstate);
50119 if (PyErr_Occurred()) SWIG_fail;
50120 }
50121 resultobj = SWIG_Py_Void();
50122 return resultobj;
50123 fail:
50124 return NULL;
50125 }
50126
50127
50128 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50129 PyObject *resultobj = 0;
50130 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50131 float result;
50132 void *argp1 = 0 ;
50133 int res1 = 0 ;
50134 PyObject *swig_obj[1] ;
50135
50136 if (!args) SWIG_fail;
50137 swig_obj[0] = args;
50138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50139 if (!SWIG_IsOK(res1)) {
50140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50141 }
50142 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50143 {
50144 PyThreadState* __tstate = wxPyBeginAllowThreads();
50145 result = (float)(arg1)->GetRatio();
50146 wxPyEndAllowThreads(__tstate);
50147 if (PyErr_Occurred()) SWIG_fail;
50148 }
50149 resultobj = SWIG_From_float(static_cast< float >(result));
50150 return resultobj;
50151 fail:
50152 return NULL;
50153 }
50154
50155
50156 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50157 PyObject *resultobj = 0;
50158 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50159 wxRect result;
50160 void *argp1 = 0 ;
50161 int res1 = 0 ;
50162 PyObject *swig_obj[1] ;
50163
50164 if (!args) SWIG_fail;
50165 swig_obj[0] = args;
50166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50167 if (!SWIG_IsOK(res1)) {
50168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50169 }
50170 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50171 {
50172 PyThreadState* __tstate = wxPyBeginAllowThreads();
50173 result = (arg1)->GetRect();
50174 wxPyEndAllowThreads(__tstate);
50175 if (PyErr_Occurred()) SWIG_fail;
50176 }
50177 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50178 return resultobj;
50179 fail:
50180 return NULL;
50181 }
50182
50183
50184 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50185 PyObject *resultobj = 0;
50186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50187 bool result;
50188 void *argp1 = 0 ;
50189 int res1 = 0 ;
50190 PyObject *swig_obj[1] ;
50191
50192 if (!args) SWIG_fail;
50193 swig_obj[0] = args;
50194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50195 if (!SWIG_IsOK(res1)) {
50196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50197 }
50198 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50199 {
50200 PyThreadState* __tstate = wxPyBeginAllowThreads();
50201 result = (bool)(arg1)->IsWindow();
50202 wxPyEndAllowThreads(__tstate);
50203 if (PyErr_Occurred()) SWIG_fail;
50204 }
50205 {
50206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50207 }
50208 return resultobj;
50209 fail:
50210 return NULL;
50211 }
50212
50213
50214 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50215 PyObject *resultobj = 0;
50216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50217 bool result;
50218 void *argp1 = 0 ;
50219 int res1 = 0 ;
50220 PyObject *swig_obj[1] ;
50221
50222 if (!args) SWIG_fail;
50223 swig_obj[0] = args;
50224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50225 if (!SWIG_IsOK(res1)) {
50226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50227 }
50228 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50229 {
50230 PyThreadState* __tstate = wxPyBeginAllowThreads();
50231 result = (bool)(arg1)->IsSizer();
50232 wxPyEndAllowThreads(__tstate);
50233 if (PyErr_Occurred()) SWIG_fail;
50234 }
50235 {
50236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50237 }
50238 return resultobj;
50239 fail:
50240 return NULL;
50241 }
50242
50243
50244 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50245 PyObject *resultobj = 0;
50246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50247 bool result;
50248 void *argp1 = 0 ;
50249 int res1 = 0 ;
50250 PyObject *swig_obj[1] ;
50251
50252 if (!args) SWIG_fail;
50253 swig_obj[0] = args;
50254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50255 if (!SWIG_IsOK(res1)) {
50256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50257 }
50258 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50259 {
50260 PyThreadState* __tstate = wxPyBeginAllowThreads();
50261 result = (bool)(arg1)->IsSpacer();
50262 wxPyEndAllowThreads(__tstate);
50263 if (PyErr_Occurred()) SWIG_fail;
50264 }
50265 {
50266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50267 }
50268 return resultobj;
50269 fail:
50270 return NULL;
50271 }
50272
50273
50274 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50275 PyObject *resultobj = 0;
50276 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50277 int arg2 ;
50278 void *argp1 = 0 ;
50279 int res1 = 0 ;
50280 int val2 ;
50281 int ecode2 = 0 ;
50282 PyObject * obj0 = 0 ;
50283 PyObject * obj1 = 0 ;
50284 char * kwnames[] = {
50285 (char *) "self",(char *) "proportion", NULL
50286 };
50287
50288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50290 if (!SWIG_IsOK(res1)) {
50291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50292 }
50293 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50294 ecode2 = SWIG_AsVal_int(obj1, &val2);
50295 if (!SWIG_IsOK(ecode2)) {
50296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50297 }
50298 arg2 = static_cast< int >(val2);
50299 {
50300 PyThreadState* __tstate = wxPyBeginAllowThreads();
50301 (arg1)->SetProportion(arg2);
50302 wxPyEndAllowThreads(__tstate);
50303 if (PyErr_Occurred()) SWIG_fail;
50304 }
50305 resultobj = SWIG_Py_Void();
50306 return resultobj;
50307 fail:
50308 return NULL;
50309 }
50310
50311
50312 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50313 PyObject *resultobj = 0;
50314 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50315 int result;
50316 void *argp1 = 0 ;
50317 int res1 = 0 ;
50318 PyObject *swig_obj[1] ;
50319
50320 if (!args) SWIG_fail;
50321 swig_obj[0] = args;
50322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50323 if (!SWIG_IsOK(res1)) {
50324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50325 }
50326 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50327 {
50328 PyThreadState* __tstate = wxPyBeginAllowThreads();
50329 result = (int)(arg1)->GetProportion();
50330 wxPyEndAllowThreads(__tstate);
50331 if (PyErr_Occurred()) SWIG_fail;
50332 }
50333 resultobj = SWIG_From_int(static_cast< int >(result));
50334 return resultobj;
50335 fail:
50336 return NULL;
50337 }
50338
50339
50340 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50341 PyObject *resultobj = 0;
50342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50343 int arg2 ;
50344 void *argp1 = 0 ;
50345 int res1 = 0 ;
50346 int val2 ;
50347 int ecode2 = 0 ;
50348 PyObject * obj0 = 0 ;
50349 PyObject * obj1 = 0 ;
50350 char * kwnames[] = {
50351 (char *) "self",(char *) "flag", NULL
50352 };
50353
50354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50356 if (!SWIG_IsOK(res1)) {
50357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50358 }
50359 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50360 ecode2 = SWIG_AsVal_int(obj1, &val2);
50361 if (!SWIG_IsOK(ecode2)) {
50362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50363 }
50364 arg2 = static_cast< int >(val2);
50365 {
50366 PyThreadState* __tstate = wxPyBeginAllowThreads();
50367 (arg1)->SetFlag(arg2);
50368 wxPyEndAllowThreads(__tstate);
50369 if (PyErr_Occurred()) SWIG_fail;
50370 }
50371 resultobj = SWIG_Py_Void();
50372 return resultobj;
50373 fail:
50374 return NULL;
50375 }
50376
50377
50378 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50379 PyObject *resultobj = 0;
50380 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50381 int result;
50382 void *argp1 = 0 ;
50383 int res1 = 0 ;
50384 PyObject *swig_obj[1] ;
50385
50386 if (!args) SWIG_fail;
50387 swig_obj[0] = args;
50388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50389 if (!SWIG_IsOK(res1)) {
50390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50391 }
50392 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50393 {
50394 PyThreadState* __tstate = wxPyBeginAllowThreads();
50395 result = (int)(arg1)->GetFlag();
50396 wxPyEndAllowThreads(__tstate);
50397 if (PyErr_Occurred()) SWIG_fail;
50398 }
50399 resultobj = SWIG_From_int(static_cast< int >(result));
50400 return resultobj;
50401 fail:
50402 return NULL;
50403 }
50404
50405
50406 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50407 PyObject *resultobj = 0;
50408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50409 int arg2 ;
50410 void *argp1 = 0 ;
50411 int res1 = 0 ;
50412 int val2 ;
50413 int ecode2 = 0 ;
50414 PyObject * obj0 = 0 ;
50415 PyObject * obj1 = 0 ;
50416 char * kwnames[] = {
50417 (char *) "self",(char *) "border", NULL
50418 };
50419
50420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50422 if (!SWIG_IsOK(res1)) {
50423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50424 }
50425 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50426 ecode2 = SWIG_AsVal_int(obj1, &val2);
50427 if (!SWIG_IsOK(ecode2)) {
50428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50429 }
50430 arg2 = static_cast< int >(val2);
50431 {
50432 PyThreadState* __tstate = wxPyBeginAllowThreads();
50433 (arg1)->SetBorder(arg2);
50434 wxPyEndAllowThreads(__tstate);
50435 if (PyErr_Occurred()) SWIG_fail;
50436 }
50437 resultobj = SWIG_Py_Void();
50438 return resultobj;
50439 fail:
50440 return NULL;
50441 }
50442
50443
50444 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50445 PyObject *resultobj = 0;
50446 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50447 int result;
50448 void *argp1 = 0 ;
50449 int res1 = 0 ;
50450 PyObject *swig_obj[1] ;
50451
50452 if (!args) SWIG_fail;
50453 swig_obj[0] = args;
50454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50455 if (!SWIG_IsOK(res1)) {
50456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50457 }
50458 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50459 {
50460 PyThreadState* __tstate = wxPyBeginAllowThreads();
50461 result = (int)(arg1)->GetBorder();
50462 wxPyEndAllowThreads(__tstate);
50463 if (PyErr_Occurred()) SWIG_fail;
50464 }
50465 resultobj = SWIG_From_int(static_cast< int >(result));
50466 return resultobj;
50467 fail:
50468 return NULL;
50469 }
50470
50471
50472 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50473 PyObject *resultobj = 0;
50474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50475 wxWindow *result = 0 ;
50476 void *argp1 = 0 ;
50477 int res1 = 0 ;
50478 PyObject *swig_obj[1] ;
50479
50480 if (!args) SWIG_fail;
50481 swig_obj[0] = args;
50482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50483 if (!SWIG_IsOK(res1)) {
50484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50485 }
50486 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50487 {
50488 PyThreadState* __tstate = wxPyBeginAllowThreads();
50489 result = (wxWindow *)(arg1)->GetWindow();
50490 wxPyEndAllowThreads(__tstate);
50491 if (PyErr_Occurred()) SWIG_fail;
50492 }
50493 {
50494 resultobj = wxPyMake_wxObject(result, 0);
50495 }
50496 return resultobj;
50497 fail:
50498 return NULL;
50499 }
50500
50501
50502 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50503 PyObject *resultobj = 0;
50504 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50505 wxWindow *arg2 = (wxWindow *) 0 ;
50506 void *argp1 = 0 ;
50507 int res1 = 0 ;
50508 void *argp2 = 0 ;
50509 int res2 = 0 ;
50510 PyObject * obj0 = 0 ;
50511 PyObject * obj1 = 0 ;
50512 char * kwnames[] = {
50513 (char *) "self",(char *) "window", NULL
50514 };
50515
50516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50518 if (!SWIG_IsOK(res1)) {
50519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50520 }
50521 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50522 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50523 if (!SWIG_IsOK(res2)) {
50524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50525 }
50526 arg2 = reinterpret_cast< wxWindow * >(argp2);
50527 {
50528 PyThreadState* __tstate = wxPyBeginAllowThreads();
50529 (arg1)->SetWindow(arg2);
50530 wxPyEndAllowThreads(__tstate);
50531 if (PyErr_Occurred()) SWIG_fail;
50532 }
50533 resultobj = SWIG_Py_Void();
50534 return resultobj;
50535 fail:
50536 return NULL;
50537 }
50538
50539
50540 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50541 PyObject *resultobj = 0;
50542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50543 wxSizer *result = 0 ;
50544 void *argp1 = 0 ;
50545 int res1 = 0 ;
50546 PyObject *swig_obj[1] ;
50547
50548 if (!args) SWIG_fail;
50549 swig_obj[0] = args;
50550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50551 if (!SWIG_IsOK(res1)) {
50552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50553 }
50554 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50555 {
50556 PyThreadState* __tstate = wxPyBeginAllowThreads();
50557 result = (wxSizer *)(arg1)->GetSizer();
50558 wxPyEndAllowThreads(__tstate);
50559 if (PyErr_Occurred()) SWIG_fail;
50560 }
50561 {
50562 resultobj = wxPyMake_wxObject(result, (bool)0);
50563 }
50564 return resultobj;
50565 fail:
50566 return NULL;
50567 }
50568
50569
50570 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50571 PyObject *resultobj = 0;
50572 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50573 wxSizer *arg2 = (wxSizer *) 0 ;
50574 void *argp1 = 0 ;
50575 int res1 = 0 ;
50576 int res2 = 0 ;
50577 PyObject * obj0 = 0 ;
50578 PyObject * obj1 = 0 ;
50579 char * kwnames[] = {
50580 (char *) "self",(char *) "sizer", NULL
50581 };
50582
50583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50585 if (!SWIG_IsOK(res1)) {
50586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50587 }
50588 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50589 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50590 if (!SWIG_IsOK(res2)) {
50591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50592 }
50593 {
50594 PyThreadState* __tstate = wxPyBeginAllowThreads();
50595 (arg1)->SetSizer(arg2);
50596 wxPyEndAllowThreads(__tstate);
50597 if (PyErr_Occurred()) SWIG_fail;
50598 }
50599 resultobj = SWIG_Py_Void();
50600 return resultobj;
50601 fail:
50602 return NULL;
50603 }
50604
50605
50606 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50607 PyObject *resultobj = 0;
50608 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50609 wxSize result;
50610 void *argp1 = 0 ;
50611 int res1 = 0 ;
50612 PyObject *swig_obj[1] ;
50613
50614 if (!args) SWIG_fail;
50615 swig_obj[0] = args;
50616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50617 if (!SWIG_IsOK(res1)) {
50618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50619 }
50620 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50621 {
50622 PyThreadState* __tstate = wxPyBeginAllowThreads();
50623 result = (arg1)->GetSpacer();
50624 wxPyEndAllowThreads(__tstate);
50625 if (PyErr_Occurred()) SWIG_fail;
50626 }
50627 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50628 return resultobj;
50629 fail:
50630 return NULL;
50631 }
50632
50633
50634 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50635 PyObject *resultobj = 0;
50636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50637 wxSize *arg2 = 0 ;
50638 void *argp1 = 0 ;
50639 int res1 = 0 ;
50640 wxSize temp2 ;
50641 PyObject * obj0 = 0 ;
50642 PyObject * obj1 = 0 ;
50643 char * kwnames[] = {
50644 (char *) "self",(char *) "size", NULL
50645 };
50646
50647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50649 if (!SWIG_IsOK(res1)) {
50650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50651 }
50652 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50653 {
50654 arg2 = &temp2;
50655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50656 }
50657 {
50658 PyThreadState* __tstate = wxPyBeginAllowThreads();
50659 (arg1)->SetSpacer((wxSize const &)*arg2);
50660 wxPyEndAllowThreads(__tstate);
50661 if (PyErr_Occurred()) SWIG_fail;
50662 }
50663 resultobj = SWIG_Py_Void();
50664 return resultobj;
50665 fail:
50666 return NULL;
50667 }
50668
50669
50670 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50671 PyObject *resultobj = 0;
50672 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50673 bool arg2 ;
50674 void *argp1 = 0 ;
50675 int res1 = 0 ;
50676 bool val2 ;
50677 int ecode2 = 0 ;
50678 PyObject * obj0 = 0 ;
50679 PyObject * obj1 = 0 ;
50680 char * kwnames[] = {
50681 (char *) "self",(char *) "show", NULL
50682 };
50683
50684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
50685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50686 if (!SWIG_IsOK(res1)) {
50687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50688 }
50689 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50690 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50691 if (!SWIG_IsOK(ecode2)) {
50692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
50693 }
50694 arg2 = static_cast< bool >(val2);
50695 {
50696 PyThreadState* __tstate = wxPyBeginAllowThreads();
50697 (arg1)->Show(arg2);
50698 wxPyEndAllowThreads(__tstate);
50699 if (PyErr_Occurred()) SWIG_fail;
50700 }
50701 resultobj = SWIG_Py_Void();
50702 return resultobj;
50703 fail:
50704 return NULL;
50705 }
50706
50707
50708 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50709 PyObject *resultobj = 0;
50710 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50711 bool result;
50712 void *argp1 = 0 ;
50713 int res1 = 0 ;
50714 PyObject *swig_obj[1] ;
50715
50716 if (!args) SWIG_fail;
50717 swig_obj[0] = args;
50718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50719 if (!SWIG_IsOK(res1)) {
50720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50721 }
50722 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50723 {
50724 PyThreadState* __tstate = wxPyBeginAllowThreads();
50725 result = (bool)(arg1)->IsShown();
50726 wxPyEndAllowThreads(__tstate);
50727 if (PyErr_Occurred()) SWIG_fail;
50728 }
50729 {
50730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50731 }
50732 return resultobj;
50733 fail:
50734 return NULL;
50735 }
50736
50737
50738 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50739 PyObject *resultobj = 0;
50740 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50741 wxPoint result;
50742 void *argp1 = 0 ;
50743 int res1 = 0 ;
50744 PyObject *swig_obj[1] ;
50745
50746 if (!args) SWIG_fail;
50747 swig_obj[0] = args;
50748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50749 if (!SWIG_IsOK(res1)) {
50750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50751 }
50752 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50753 {
50754 PyThreadState* __tstate = wxPyBeginAllowThreads();
50755 result = (arg1)->GetPosition();
50756 wxPyEndAllowThreads(__tstate);
50757 if (PyErr_Occurred()) SWIG_fail;
50758 }
50759 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50760 return resultobj;
50761 fail:
50762 return NULL;
50763 }
50764
50765
50766 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50767 PyObject *resultobj = 0;
50768 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50769 PyObject *result = 0 ;
50770 void *argp1 = 0 ;
50771 int res1 = 0 ;
50772 PyObject *swig_obj[1] ;
50773
50774 if (!args) SWIG_fail;
50775 swig_obj[0] = args;
50776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50777 if (!SWIG_IsOK(res1)) {
50778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50779 }
50780 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50781 {
50782 PyThreadState* __tstate = wxPyBeginAllowThreads();
50783 result = (PyObject *)wxSizerItem_GetUserData(arg1);
50784 wxPyEndAllowThreads(__tstate);
50785 if (PyErr_Occurred()) SWIG_fail;
50786 }
50787 resultobj = result;
50788 return resultobj;
50789 fail:
50790 return NULL;
50791 }
50792
50793
50794 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50795 PyObject *resultobj = 0;
50796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50797 PyObject *arg2 = (PyObject *) 0 ;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 PyObject * obj0 = 0 ;
50801 PyObject * obj1 = 0 ;
50802 char * kwnames[] = {
50803 (char *) "self",(char *) "userData", NULL
50804 };
50805
50806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
50807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50808 if (!SWIG_IsOK(res1)) {
50809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50810 }
50811 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50812 arg2 = obj1;
50813 {
50814 PyThreadState* __tstate = wxPyBeginAllowThreads();
50815 wxSizerItem_SetUserData(arg1,arg2);
50816 wxPyEndAllowThreads(__tstate);
50817 if (PyErr_Occurred()) SWIG_fail;
50818 }
50819 resultobj = SWIG_Py_Void();
50820 return resultobj;
50821 fail:
50822 return NULL;
50823 }
50824
50825
50826 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50827 PyObject *obj;
50828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50829 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
50830 return SWIG_Py_Void();
50831 }
50832
50833 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50834 return SWIG_Python_InitShadowInstance(args);
50835 }
50836
50837 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50838 PyObject *resultobj = 0;
50839 wxSizer *arg1 = (wxSizer *) 0 ;
50840 void *argp1 = 0 ;
50841 int res1 = 0 ;
50842 PyObject *swig_obj[1] ;
50843
50844 if (!args) SWIG_fail;
50845 swig_obj[0] = args;
50846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50847 if (!SWIG_IsOK(res1)) {
50848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50849 }
50850 arg1 = reinterpret_cast< wxSizer * >(argp1);
50851 {
50852 PyThreadState* __tstate = wxPyBeginAllowThreads();
50853 delete arg1;
50854
50855 wxPyEndAllowThreads(__tstate);
50856 if (PyErr_Occurred()) SWIG_fail;
50857 }
50858 resultobj = SWIG_Py_Void();
50859 return resultobj;
50860 fail:
50861 return NULL;
50862 }
50863
50864
50865 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50866 PyObject *resultobj = 0;
50867 wxSizer *arg1 = (wxSizer *) 0 ;
50868 PyObject *arg2 = (PyObject *) 0 ;
50869 void *argp1 = 0 ;
50870 int res1 = 0 ;
50871 PyObject * obj0 = 0 ;
50872 PyObject * obj1 = 0 ;
50873 char * kwnames[] = {
50874 (char *) "self",(char *) "_self", NULL
50875 };
50876
50877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
50878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50879 if (!SWIG_IsOK(res1)) {
50880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
50881 }
50882 arg1 = reinterpret_cast< wxSizer * >(argp1);
50883 arg2 = obj1;
50884 {
50885 PyThreadState* __tstate = wxPyBeginAllowThreads();
50886 wxSizer__setOORInfo(arg1,arg2);
50887 wxPyEndAllowThreads(__tstate);
50888 if (PyErr_Occurred()) SWIG_fail;
50889 }
50890 resultobj = SWIG_Py_Void();
50891 return resultobj;
50892 fail:
50893 return NULL;
50894 }
50895
50896
50897 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50898 PyObject *resultobj = 0;
50899 wxSizer *arg1 = (wxSizer *) 0 ;
50900 PyObject *arg2 = (PyObject *) 0 ;
50901 int arg3 = (int) 0 ;
50902 int arg4 = (int) 0 ;
50903 int arg5 = (int) 0 ;
50904 PyObject *arg6 = (PyObject *) NULL ;
50905 wxSizerItem *result = 0 ;
50906 void *argp1 = 0 ;
50907 int res1 = 0 ;
50908 int val3 ;
50909 int ecode3 = 0 ;
50910 int val4 ;
50911 int ecode4 = 0 ;
50912 int val5 ;
50913 int ecode5 = 0 ;
50914 PyObject * obj0 = 0 ;
50915 PyObject * obj1 = 0 ;
50916 PyObject * obj2 = 0 ;
50917 PyObject * obj3 = 0 ;
50918 PyObject * obj4 = 0 ;
50919 PyObject * obj5 = 0 ;
50920 char * kwnames[] = {
50921 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50922 };
50923
50924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50926 if (!SWIG_IsOK(res1)) {
50927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
50928 }
50929 arg1 = reinterpret_cast< wxSizer * >(argp1);
50930 arg2 = obj1;
50931 if (obj2) {
50932 ecode3 = SWIG_AsVal_int(obj2, &val3);
50933 if (!SWIG_IsOK(ecode3)) {
50934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
50935 }
50936 arg3 = static_cast< int >(val3);
50937 }
50938 if (obj3) {
50939 ecode4 = SWIG_AsVal_int(obj3, &val4);
50940 if (!SWIG_IsOK(ecode4)) {
50941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
50942 }
50943 arg4 = static_cast< int >(val4);
50944 }
50945 if (obj4) {
50946 ecode5 = SWIG_AsVal_int(obj4, &val5);
50947 if (!SWIG_IsOK(ecode5)) {
50948 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
50949 }
50950 arg5 = static_cast< int >(val5);
50951 }
50952 if (obj5) {
50953 arg6 = obj5;
50954 }
50955 {
50956 PyThreadState* __tstate = wxPyBeginAllowThreads();
50957 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
50958 wxPyEndAllowThreads(__tstate);
50959 if (PyErr_Occurred()) SWIG_fail;
50960 }
50961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50962 return resultobj;
50963 fail:
50964 return NULL;
50965 }
50966
50967
50968 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50969 PyObject *resultobj = 0;
50970 wxSizer *arg1 = (wxSizer *) 0 ;
50971 PyObject *arg2 = (PyObject *) 0 ;
50972 wxSizerFlags *arg3 = 0 ;
50973 wxSizerItem *result = 0 ;
50974 void *argp1 = 0 ;
50975 int res1 = 0 ;
50976 void *argp3 = 0 ;
50977 int res3 = 0 ;
50978 PyObject * obj0 = 0 ;
50979 PyObject * obj1 = 0 ;
50980 PyObject * obj2 = 0 ;
50981 char * kwnames[] = {
50982 (char *) "self",(char *) "item",(char *) "flags", NULL
50983 };
50984
50985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50987 if (!SWIG_IsOK(res1)) {
50988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
50989 }
50990 arg1 = reinterpret_cast< wxSizer * >(argp1);
50991 arg2 = obj1;
50992 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
50993 if (!SWIG_IsOK(res3)) {
50994 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
50995 }
50996 if (!argp3) {
50997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
50998 }
50999 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51000 {
51001 PyThreadState* __tstate = wxPyBeginAllowThreads();
51002 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51003 wxPyEndAllowThreads(__tstate);
51004 if (PyErr_Occurred()) SWIG_fail;
51005 }
51006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51007 return resultobj;
51008 fail:
51009 return NULL;
51010 }
51011
51012
51013 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51014 PyObject *resultobj = 0;
51015 wxSizer *arg1 = (wxSizer *) 0 ;
51016 int arg2 ;
51017 PyObject *arg3 = (PyObject *) 0 ;
51018 int arg4 = (int) 0 ;
51019 int arg5 = (int) 0 ;
51020 int arg6 = (int) 0 ;
51021 PyObject *arg7 = (PyObject *) NULL ;
51022 wxSizerItem *result = 0 ;
51023 void *argp1 = 0 ;
51024 int res1 = 0 ;
51025 int val2 ;
51026 int ecode2 = 0 ;
51027 int val4 ;
51028 int ecode4 = 0 ;
51029 int val5 ;
51030 int ecode5 = 0 ;
51031 int val6 ;
51032 int ecode6 = 0 ;
51033 PyObject * obj0 = 0 ;
51034 PyObject * obj1 = 0 ;
51035 PyObject * obj2 = 0 ;
51036 PyObject * obj3 = 0 ;
51037 PyObject * obj4 = 0 ;
51038 PyObject * obj5 = 0 ;
51039 PyObject * obj6 = 0 ;
51040 char * kwnames[] = {
51041 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51042 };
51043
51044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51046 if (!SWIG_IsOK(res1)) {
51047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51048 }
51049 arg1 = reinterpret_cast< wxSizer * >(argp1);
51050 ecode2 = SWIG_AsVal_int(obj1, &val2);
51051 if (!SWIG_IsOK(ecode2)) {
51052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51053 }
51054 arg2 = static_cast< int >(val2);
51055 arg3 = obj2;
51056 if (obj3) {
51057 ecode4 = SWIG_AsVal_int(obj3, &val4);
51058 if (!SWIG_IsOK(ecode4)) {
51059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51060 }
51061 arg4 = static_cast< int >(val4);
51062 }
51063 if (obj4) {
51064 ecode5 = SWIG_AsVal_int(obj4, &val5);
51065 if (!SWIG_IsOK(ecode5)) {
51066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51067 }
51068 arg5 = static_cast< int >(val5);
51069 }
51070 if (obj5) {
51071 ecode6 = SWIG_AsVal_int(obj5, &val6);
51072 if (!SWIG_IsOK(ecode6)) {
51073 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51074 }
51075 arg6 = static_cast< int >(val6);
51076 }
51077 if (obj6) {
51078 arg7 = obj6;
51079 }
51080 {
51081 PyThreadState* __tstate = wxPyBeginAllowThreads();
51082 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51083 wxPyEndAllowThreads(__tstate);
51084 if (PyErr_Occurred()) SWIG_fail;
51085 }
51086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51087 return resultobj;
51088 fail:
51089 return NULL;
51090 }
51091
51092
51093 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51094 PyObject *resultobj = 0;
51095 wxSizer *arg1 = (wxSizer *) 0 ;
51096 int arg2 ;
51097 PyObject *arg3 = (PyObject *) 0 ;
51098 wxSizerFlags *arg4 = 0 ;
51099 wxSizerItem *result = 0 ;
51100 void *argp1 = 0 ;
51101 int res1 = 0 ;
51102 int val2 ;
51103 int ecode2 = 0 ;
51104 void *argp4 = 0 ;
51105 int res4 = 0 ;
51106 PyObject * obj0 = 0 ;
51107 PyObject * obj1 = 0 ;
51108 PyObject * obj2 = 0 ;
51109 PyObject * obj3 = 0 ;
51110 char * kwnames[] = {
51111 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51112 };
51113
51114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51116 if (!SWIG_IsOK(res1)) {
51117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51118 }
51119 arg1 = reinterpret_cast< wxSizer * >(argp1);
51120 ecode2 = SWIG_AsVal_int(obj1, &val2);
51121 if (!SWIG_IsOK(ecode2)) {
51122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51123 }
51124 arg2 = static_cast< int >(val2);
51125 arg3 = obj2;
51126 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51127 if (!SWIG_IsOK(res4)) {
51128 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51129 }
51130 if (!argp4) {
51131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51132 }
51133 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51134 {
51135 PyThreadState* __tstate = wxPyBeginAllowThreads();
51136 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51137 wxPyEndAllowThreads(__tstate);
51138 if (PyErr_Occurred()) SWIG_fail;
51139 }
51140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51141 return resultobj;
51142 fail:
51143 return NULL;
51144 }
51145
51146
51147 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51148 PyObject *resultobj = 0;
51149 wxSizer *arg1 = (wxSizer *) 0 ;
51150 PyObject *arg2 = (PyObject *) 0 ;
51151 int arg3 = (int) 0 ;
51152 int arg4 = (int) 0 ;
51153 int arg5 = (int) 0 ;
51154 PyObject *arg6 = (PyObject *) NULL ;
51155 wxSizerItem *result = 0 ;
51156 void *argp1 = 0 ;
51157 int res1 = 0 ;
51158 int val3 ;
51159 int ecode3 = 0 ;
51160 int val4 ;
51161 int ecode4 = 0 ;
51162 int val5 ;
51163 int ecode5 = 0 ;
51164 PyObject * obj0 = 0 ;
51165 PyObject * obj1 = 0 ;
51166 PyObject * obj2 = 0 ;
51167 PyObject * obj3 = 0 ;
51168 PyObject * obj4 = 0 ;
51169 PyObject * obj5 = 0 ;
51170 char * kwnames[] = {
51171 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51172 };
51173
51174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51176 if (!SWIG_IsOK(res1)) {
51177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51178 }
51179 arg1 = reinterpret_cast< wxSizer * >(argp1);
51180 arg2 = obj1;
51181 if (obj2) {
51182 ecode3 = SWIG_AsVal_int(obj2, &val3);
51183 if (!SWIG_IsOK(ecode3)) {
51184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51185 }
51186 arg3 = static_cast< int >(val3);
51187 }
51188 if (obj3) {
51189 ecode4 = SWIG_AsVal_int(obj3, &val4);
51190 if (!SWIG_IsOK(ecode4)) {
51191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51192 }
51193 arg4 = static_cast< int >(val4);
51194 }
51195 if (obj4) {
51196 ecode5 = SWIG_AsVal_int(obj4, &val5);
51197 if (!SWIG_IsOK(ecode5)) {
51198 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51199 }
51200 arg5 = static_cast< int >(val5);
51201 }
51202 if (obj5) {
51203 arg6 = obj5;
51204 }
51205 {
51206 PyThreadState* __tstate = wxPyBeginAllowThreads();
51207 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51208 wxPyEndAllowThreads(__tstate);
51209 if (PyErr_Occurred()) SWIG_fail;
51210 }
51211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51212 return resultobj;
51213 fail:
51214 return NULL;
51215 }
51216
51217
51218 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51219 PyObject *resultobj = 0;
51220 wxSizer *arg1 = (wxSizer *) 0 ;
51221 PyObject *arg2 = (PyObject *) 0 ;
51222 wxSizerFlags *arg3 = 0 ;
51223 wxSizerItem *result = 0 ;
51224 void *argp1 = 0 ;
51225 int res1 = 0 ;
51226 void *argp3 = 0 ;
51227 int res3 = 0 ;
51228 PyObject * obj0 = 0 ;
51229 PyObject * obj1 = 0 ;
51230 PyObject * obj2 = 0 ;
51231 char * kwnames[] = {
51232 (char *) "self",(char *) "item",(char *) "flags", NULL
51233 };
51234
51235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51237 if (!SWIG_IsOK(res1)) {
51238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51239 }
51240 arg1 = reinterpret_cast< wxSizer * >(argp1);
51241 arg2 = obj1;
51242 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51243 if (!SWIG_IsOK(res3)) {
51244 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51245 }
51246 if (!argp3) {
51247 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51248 }
51249 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51250 {
51251 PyThreadState* __tstate = wxPyBeginAllowThreads();
51252 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51253 wxPyEndAllowThreads(__tstate);
51254 if (PyErr_Occurred()) SWIG_fail;
51255 }
51256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51257 return resultobj;
51258 fail:
51259 return NULL;
51260 }
51261
51262
51263 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51264 PyObject *resultobj = 0;
51265 wxSizer *arg1 = (wxSizer *) 0 ;
51266 PyObject *arg2 = (PyObject *) 0 ;
51267 bool result;
51268 void *argp1 = 0 ;
51269 int res1 = 0 ;
51270 PyObject * obj0 = 0 ;
51271 PyObject * obj1 = 0 ;
51272 char * kwnames[] = {
51273 (char *) "self",(char *) "item", NULL
51274 };
51275
51276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51278 if (!SWIG_IsOK(res1)) {
51279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51280 }
51281 arg1 = reinterpret_cast< wxSizer * >(argp1);
51282 arg2 = obj1;
51283 {
51284 PyThreadState* __tstate = wxPyBeginAllowThreads();
51285 result = (bool)wxSizer_Remove(arg1,arg2);
51286 wxPyEndAllowThreads(__tstate);
51287 if (PyErr_Occurred()) SWIG_fail;
51288 }
51289 {
51290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51291 }
51292 return resultobj;
51293 fail:
51294 return NULL;
51295 }
51296
51297
51298 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51299 PyObject *resultobj = 0;
51300 wxSizer *arg1 = (wxSizer *) 0 ;
51301 PyObject *arg2 = (PyObject *) 0 ;
51302 bool result;
51303 void *argp1 = 0 ;
51304 int res1 = 0 ;
51305 PyObject * obj0 = 0 ;
51306 PyObject * obj1 = 0 ;
51307 char * kwnames[] = {
51308 (char *) "self",(char *) "item", NULL
51309 };
51310
51311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51313 if (!SWIG_IsOK(res1)) {
51314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51315 }
51316 arg1 = reinterpret_cast< wxSizer * >(argp1);
51317 arg2 = obj1;
51318 {
51319 PyThreadState* __tstate = wxPyBeginAllowThreads();
51320 result = (bool)wxSizer_Detach(arg1,arg2);
51321 wxPyEndAllowThreads(__tstate);
51322 if (PyErr_Occurred()) SWIG_fail;
51323 }
51324 {
51325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51326 }
51327 return resultobj;
51328 fail:
51329 return NULL;
51330 }
51331
51332
51333 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51334 PyObject *resultobj = 0;
51335 wxSizer *arg1 = (wxSizer *) 0 ;
51336 PyObject *arg2 = (PyObject *) 0 ;
51337 bool arg3 = (bool) false ;
51338 wxSizerItem *result = 0 ;
51339 void *argp1 = 0 ;
51340 int res1 = 0 ;
51341 bool val3 ;
51342 int ecode3 = 0 ;
51343 PyObject * obj0 = 0 ;
51344 PyObject * obj1 = 0 ;
51345 PyObject * obj2 = 0 ;
51346 char * kwnames[] = {
51347 (char *) "self",(char *) "item",(char *) "recursive", NULL
51348 };
51349
51350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51352 if (!SWIG_IsOK(res1)) {
51353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51354 }
51355 arg1 = reinterpret_cast< wxSizer * >(argp1);
51356 arg2 = obj1;
51357 if (obj2) {
51358 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51359 if (!SWIG_IsOK(ecode3)) {
51360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
51361 }
51362 arg3 = static_cast< bool >(val3);
51363 }
51364 {
51365 PyThreadState* __tstate = wxPyBeginAllowThreads();
51366 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
51367 wxPyEndAllowThreads(__tstate);
51368 if (PyErr_Occurred()) SWIG_fail;
51369 }
51370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51371 return resultobj;
51372 fail:
51373 return NULL;
51374 }
51375
51376
51377 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51378 PyObject *resultobj = 0;
51379 wxSizer *arg1 = (wxSizer *) 0 ;
51380 PyObject *arg2 = (PyObject *) 0 ;
51381 wxSize *arg3 = 0 ;
51382 void *argp1 = 0 ;
51383 int res1 = 0 ;
51384 wxSize temp3 ;
51385 PyObject * obj0 = 0 ;
51386 PyObject * obj1 = 0 ;
51387 PyObject * obj2 = 0 ;
51388 char * kwnames[] = {
51389 (char *) "self",(char *) "item",(char *) "size", NULL
51390 };
51391
51392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51394 if (!SWIG_IsOK(res1)) {
51395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51396 }
51397 arg1 = reinterpret_cast< wxSizer * >(argp1);
51398 arg2 = obj1;
51399 {
51400 arg3 = &temp3;
51401 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
51402 }
51403 {
51404 PyThreadState* __tstate = wxPyBeginAllowThreads();
51405 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
51406 wxPyEndAllowThreads(__tstate);
51407 if (PyErr_Occurred()) SWIG_fail;
51408 }
51409 resultobj = SWIG_Py_Void();
51410 return resultobj;
51411 fail:
51412 return NULL;
51413 }
51414
51415
51416 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51417 PyObject *resultobj = 0;
51418 wxSizer *arg1 = (wxSizer *) 0 ;
51419 wxWindow *arg2 = (wxWindow *) 0 ;
51420 wxWindow *arg3 = (wxWindow *) 0 ;
51421 bool arg4 = (bool) false ;
51422 bool result;
51423 void *argp1 = 0 ;
51424 int res1 = 0 ;
51425 void *argp2 = 0 ;
51426 int res2 = 0 ;
51427 void *argp3 = 0 ;
51428 int res3 = 0 ;
51429 bool val4 ;
51430 int ecode4 = 0 ;
51431 PyObject * obj0 = 0 ;
51432 PyObject * obj1 = 0 ;
51433 PyObject * obj2 = 0 ;
51434 PyObject * obj3 = 0 ;
51435 char * kwnames[] = {
51436 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
51437 };
51438
51439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51441 if (!SWIG_IsOK(res1)) {
51442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
51443 }
51444 arg1 = reinterpret_cast< wxSizer * >(argp1);
51445 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51446 if (!SWIG_IsOK(res2)) {
51447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51448 }
51449 arg2 = reinterpret_cast< wxWindow * >(argp2);
51450 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51451 if (!SWIG_IsOK(res3)) {
51452 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
51453 }
51454 arg3 = reinterpret_cast< wxWindow * >(argp3);
51455 if (obj3) {
51456 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51457 if (!SWIG_IsOK(ecode4)) {
51458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
51459 }
51460 arg4 = static_cast< bool >(val4);
51461 }
51462 {
51463 PyThreadState* __tstate = wxPyBeginAllowThreads();
51464 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51465 wxPyEndAllowThreads(__tstate);
51466 if (PyErr_Occurred()) SWIG_fail;
51467 }
51468 {
51469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51470 }
51471 return resultobj;
51472 fail:
51473 return NULL;
51474 }
51475
51476
51477 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51478 PyObject *resultobj = 0;
51479 wxSizer *arg1 = (wxSizer *) 0 ;
51480 wxSizer *arg2 = (wxSizer *) 0 ;
51481 wxSizer *arg3 = (wxSizer *) 0 ;
51482 bool arg4 = (bool) false ;
51483 bool result;
51484 void *argp1 = 0 ;
51485 int res1 = 0 ;
51486 void *argp2 = 0 ;
51487 int res2 = 0 ;
51488 void *argp3 = 0 ;
51489 int res3 = 0 ;
51490 bool val4 ;
51491 int ecode4 = 0 ;
51492 PyObject * obj0 = 0 ;
51493 PyObject * obj1 = 0 ;
51494 PyObject * obj2 = 0 ;
51495 PyObject * obj3 = 0 ;
51496 char * kwnames[] = {
51497 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
51498 };
51499
51500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51502 if (!SWIG_IsOK(res1)) {
51503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51504 }
51505 arg1 = reinterpret_cast< wxSizer * >(argp1);
51506 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51507 if (!SWIG_IsOK(res2)) {
51508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51509 }
51510 arg2 = reinterpret_cast< wxSizer * >(argp2);
51511 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
51512 if (!SWIG_IsOK(res3)) {
51513 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
51514 }
51515 arg3 = reinterpret_cast< wxSizer * >(argp3);
51516 if (obj3) {
51517 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51518 if (!SWIG_IsOK(ecode4)) {
51519 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
51520 }
51521 arg4 = static_cast< bool >(val4);
51522 }
51523 {
51524 PyThreadState* __tstate = wxPyBeginAllowThreads();
51525 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51526 wxPyEndAllowThreads(__tstate);
51527 if (PyErr_Occurred()) SWIG_fail;
51528 }
51529 {
51530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51531 }
51532 return resultobj;
51533 fail:
51534 return NULL;
51535 }
51536
51537
51538 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51539 PyObject *resultobj = 0;
51540 wxSizer *arg1 = (wxSizer *) 0 ;
51541 size_t arg2 ;
51542 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51543 bool result;
51544 void *argp1 = 0 ;
51545 int res1 = 0 ;
51546 size_t val2 ;
51547 int ecode2 = 0 ;
51548 void *argp3 = 0 ;
51549 int res3 = 0 ;
51550 PyObject * obj0 = 0 ;
51551 PyObject * obj1 = 0 ;
51552 PyObject * obj2 = 0 ;
51553 char * kwnames[] = {
51554 (char *) "self",(char *) "index",(char *) "newitem", NULL
51555 };
51556
51557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51559 if (!SWIG_IsOK(res1)) {
51560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51561 }
51562 arg1 = reinterpret_cast< wxSizer * >(argp1);
51563 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51564 if (!SWIG_IsOK(ecode2)) {
51565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
51566 }
51567 arg2 = static_cast< size_t >(val2);
51568 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51569 if (!SWIG_IsOK(res3)) {
51570 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51571 }
51572 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
51573 {
51574 PyThreadState* __tstate = wxPyBeginAllowThreads();
51575 result = (bool)(arg1)->Replace(arg2,arg3);
51576 wxPyEndAllowThreads(__tstate);
51577 if (PyErr_Occurred()) SWIG_fail;
51578 }
51579 {
51580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51581 }
51582 return resultobj;
51583 fail:
51584 return NULL;
51585 }
51586
51587
51588 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51589 PyObject *resultobj = 0;
51590 wxSizer *arg1 = (wxSizer *) 0 ;
51591 wxWindow *arg2 = (wxWindow *) 0 ;
51592 void *argp1 = 0 ;
51593 int res1 = 0 ;
51594 void *argp2 = 0 ;
51595 int res2 = 0 ;
51596 PyObject * obj0 = 0 ;
51597 PyObject * obj1 = 0 ;
51598 char * kwnames[] = {
51599 (char *) "self",(char *) "window", NULL
51600 };
51601
51602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51604 if (!SWIG_IsOK(res1)) {
51605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
51606 }
51607 arg1 = reinterpret_cast< wxSizer * >(argp1);
51608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51609 if (!SWIG_IsOK(res2)) {
51610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51611 }
51612 arg2 = reinterpret_cast< wxWindow * >(argp2);
51613 {
51614 PyThreadState* __tstate = wxPyBeginAllowThreads();
51615 (arg1)->SetContainingWindow(arg2);
51616 wxPyEndAllowThreads(__tstate);
51617 if (PyErr_Occurred()) SWIG_fail;
51618 }
51619 resultobj = SWIG_Py_Void();
51620 return resultobj;
51621 fail:
51622 return NULL;
51623 }
51624
51625
51626 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51627 PyObject *resultobj = 0;
51628 wxSizer *arg1 = (wxSizer *) 0 ;
51629 wxWindow *result = 0 ;
51630 void *argp1 = 0 ;
51631 int res1 = 0 ;
51632 PyObject *swig_obj[1] ;
51633
51634 if (!args) SWIG_fail;
51635 swig_obj[0] = args;
51636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51637 if (!SWIG_IsOK(res1)) {
51638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
51639 }
51640 arg1 = reinterpret_cast< wxSizer * >(argp1);
51641 {
51642 PyThreadState* __tstate = wxPyBeginAllowThreads();
51643 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
51644 wxPyEndAllowThreads(__tstate);
51645 if (PyErr_Occurred()) SWIG_fail;
51646 }
51647 {
51648 resultobj = wxPyMake_wxObject(result, 0);
51649 }
51650 return resultobj;
51651 fail:
51652 return NULL;
51653 }
51654
51655
51656 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51657 PyObject *resultobj = 0;
51658 wxSizer *arg1 = (wxSizer *) 0 ;
51659 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51660 wxSizerItem *result = 0 ;
51661 void *argp1 = 0 ;
51662 int res1 = 0 ;
51663 int res2 = 0 ;
51664 PyObject * obj0 = 0 ;
51665 PyObject * obj1 = 0 ;
51666 char * kwnames[] = {
51667 (char *) "self",(char *) "item", NULL
51668 };
51669
51670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51672 if (!SWIG_IsOK(res1)) {
51673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51674 }
51675 arg1 = reinterpret_cast< wxSizer * >(argp1);
51676 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51677 if (!SWIG_IsOK(res2)) {
51678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51679 }
51680 {
51681 PyThreadState* __tstate = wxPyBeginAllowThreads();
51682 result = (wxSizerItem *)(arg1)->Add(arg2);
51683 wxPyEndAllowThreads(__tstate);
51684 if (PyErr_Occurred()) SWIG_fail;
51685 }
51686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51687 return resultobj;
51688 fail:
51689 return NULL;
51690 }
51691
51692
51693 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51694 PyObject *resultobj = 0;
51695 wxSizer *arg1 = (wxSizer *) 0 ;
51696 size_t arg2 ;
51697 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51698 wxSizerItem *result = 0 ;
51699 void *argp1 = 0 ;
51700 int res1 = 0 ;
51701 size_t val2 ;
51702 int ecode2 = 0 ;
51703 int res3 = 0 ;
51704 PyObject * obj0 = 0 ;
51705 PyObject * obj1 = 0 ;
51706 PyObject * obj2 = 0 ;
51707 char * kwnames[] = {
51708 (char *) "self",(char *) "index",(char *) "item", NULL
51709 };
51710
51711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51713 if (!SWIG_IsOK(res1)) {
51714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51715 }
51716 arg1 = reinterpret_cast< wxSizer * >(argp1);
51717 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51718 if (!SWIG_IsOK(ecode2)) {
51719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
51720 }
51721 arg2 = static_cast< size_t >(val2);
51722 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51723 if (!SWIG_IsOK(res3)) {
51724 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51725 }
51726 {
51727 PyThreadState* __tstate = wxPyBeginAllowThreads();
51728 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
51729 wxPyEndAllowThreads(__tstate);
51730 if (PyErr_Occurred()) SWIG_fail;
51731 }
51732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51733 return resultobj;
51734 fail:
51735 return NULL;
51736 }
51737
51738
51739 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51740 PyObject *resultobj = 0;
51741 wxSizer *arg1 = (wxSizer *) 0 ;
51742 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51743 wxSizerItem *result = 0 ;
51744 void *argp1 = 0 ;
51745 int res1 = 0 ;
51746 int res2 = 0 ;
51747 PyObject * obj0 = 0 ;
51748 PyObject * obj1 = 0 ;
51749 char * kwnames[] = {
51750 (char *) "self",(char *) "item", NULL
51751 };
51752
51753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
51754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51755 if (!SWIG_IsOK(res1)) {
51756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51757 }
51758 arg1 = reinterpret_cast< wxSizer * >(argp1);
51759 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51760 if (!SWIG_IsOK(res2)) {
51761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51762 }
51763 {
51764 PyThreadState* __tstate = wxPyBeginAllowThreads();
51765 result = (wxSizerItem *)(arg1)->Prepend(arg2);
51766 wxPyEndAllowThreads(__tstate);
51767 if (PyErr_Occurred()) SWIG_fail;
51768 }
51769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51770 return resultobj;
51771 fail:
51772 return NULL;
51773 }
51774
51775
51776 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51777 PyObject *resultobj = 0;
51778 wxSizer *arg1 = (wxSizer *) 0 ;
51779 int arg2 ;
51780 int arg3 ;
51781 int arg4 ;
51782 int arg5 ;
51783 void *argp1 = 0 ;
51784 int res1 = 0 ;
51785 int val2 ;
51786 int ecode2 = 0 ;
51787 int val3 ;
51788 int ecode3 = 0 ;
51789 int val4 ;
51790 int ecode4 = 0 ;
51791 int val5 ;
51792 int ecode5 = 0 ;
51793 PyObject * obj0 = 0 ;
51794 PyObject * obj1 = 0 ;
51795 PyObject * obj2 = 0 ;
51796 PyObject * obj3 = 0 ;
51797 PyObject * obj4 = 0 ;
51798 char * kwnames[] = {
51799 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
51800 };
51801
51802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
51803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51804 if (!SWIG_IsOK(res1)) {
51805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
51806 }
51807 arg1 = reinterpret_cast< wxSizer * >(argp1);
51808 ecode2 = SWIG_AsVal_int(obj1, &val2);
51809 if (!SWIG_IsOK(ecode2)) {
51810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
51811 }
51812 arg2 = static_cast< int >(val2);
51813 ecode3 = SWIG_AsVal_int(obj2, &val3);
51814 if (!SWIG_IsOK(ecode3)) {
51815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
51816 }
51817 arg3 = static_cast< int >(val3);
51818 ecode4 = SWIG_AsVal_int(obj3, &val4);
51819 if (!SWIG_IsOK(ecode4)) {
51820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
51821 }
51822 arg4 = static_cast< int >(val4);
51823 ecode5 = SWIG_AsVal_int(obj4, &val5);
51824 if (!SWIG_IsOK(ecode5)) {
51825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
51826 }
51827 arg5 = static_cast< int >(val5);
51828 {
51829 PyThreadState* __tstate = wxPyBeginAllowThreads();
51830 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
51831 wxPyEndAllowThreads(__tstate);
51832 if (PyErr_Occurred()) SWIG_fail;
51833 }
51834 resultobj = SWIG_Py_Void();
51835 return resultobj;
51836 fail:
51837 return NULL;
51838 }
51839
51840
51841 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51842 PyObject *resultobj = 0;
51843 wxSizer *arg1 = (wxSizer *) 0 ;
51844 wxSize *arg2 = 0 ;
51845 void *argp1 = 0 ;
51846 int res1 = 0 ;
51847 wxSize temp2 ;
51848 PyObject * obj0 = 0 ;
51849 PyObject * obj1 = 0 ;
51850 char * kwnames[] = {
51851 (char *) "self",(char *) "size", NULL
51852 };
51853
51854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
51855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51856 if (!SWIG_IsOK(res1)) {
51857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51858 }
51859 arg1 = reinterpret_cast< wxSizer * >(argp1);
51860 {
51861 arg2 = &temp2;
51862 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51863 }
51864 {
51865 PyThreadState* __tstate = wxPyBeginAllowThreads();
51866 (arg1)->SetMinSize((wxSize const &)*arg2);
51867 wxPyEndAllowThreads(__tstate);
51868 if (PyErr_Occurred()) SWIG_fail;
51869 }
51870 resultobj = SWIG_Py_Void();
51871 return resultobj;
51872 fail:
51873 return NULL;
51874 }
51875
51876
51877 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51878 PyObject *resultobj = 0;
51879 wxSizer *arg1 = (wxSizer *) 0 ;
51880 wxSize result;
51881 void *argp1 = 0 ;
51882 int res1 = 0 ;
51883 PyObject *swig_obj[1] ;
51884
51885 if (!args) SWIG_fail;
51886 swig_obj[0] = args;
51887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51888 if (!SWIG_IsOK(res1)) {
51889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51890 }
51891 arg1 = reinterpret_cast< wxSizer * >(argp1);
51892 {
51893 PyThreadState* __tstate = wxPyBeginAllowThreads();
51894 result = (arg1)->GetSize();
51895 wxPyEndAllowThreads(__tstate);
51896 if (PyErr_Occurred()) SWIG_fail;
51897 }
51898 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51899 return resultobj;
51900 fail:
51901 return NULL;
51902 }
51903
51904
51905 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51906 PyObject *resultobj = 0;
51907 wxSizer *arg1 = (wxSizer *) 0 ;
51908 wxPoint result;
51909 void *argp1 = 0 ;
51910 int res1 = 0 ;
51911 PyObject *swig_obj[1] ;
51912
51913 if (!args) SWIG_fail;
51914 swig_obj[0] = args;
51915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51916 if (!SWIG_IsOK(res1)) {
51917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
51918 }
51919 arg1 = reinterpret_cast< wxSizer * >(argp1);
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 result = (arg1)->GetPosition();
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51927 return resultobj;
51928 fail:
51929 return NULL;
51930 }
51931
51932
51933 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51934 PyObject *resultobj = 0;
51935 wxSizer *arg1 = (wxSizer *) 0 ;
51936 wxSize result;
51937 void *argp1 = 0 ;
51938 int res1 = 0 ;
51939 PyObject *swig_obj[1] ;
51940
51941 if (!args) SWIG_fail;
51942 swig_obj[0] = args;
51943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51944 if (!SWIG_IsOK(res1)) {
51945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51946 }
51947 arg1 = reinterpret_cast< wxSizer * >(argp1);
51948 {
51949 PyThreadState* __tstate = wxPyBeginAllowThreads();
51950 result = (arg1)->GetMinSize();
51951 wxPyEndAllowThreads(__tstate);
51952 if (PyErr_Occurred()) SWIG_fail;
51953 }
51954 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51955 return resultobj;
51956 fail:
51957 return NULL;
51958 }
51959
51960
51961 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51962 PyObject *resultobj = 0;
51963 wxSizer *arg1 = (wxSizer *) 0 ;
51964 void *argp1 = 0 ;
51965 int res1 = 0 ;
51966 PyObject *swig_obj[1] ;
51967
51968 if (!args) SWIG_fail;
51969 swig_obj[0] = args;
51970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51971 if (!SWIG_IsOK(res1)) {
51972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
51973 }
51974 arg1 = reinterpret_cast< wxSizer * >(argp1);
51975 {
51976 PyThreadState* __tstate = wxPyBeginAllowThreads();
51977 (arg1)->RecalcSizes();
51978 wxPyEndAllowThreads(__tstate);
51979 if (PyErr_Occurred()) SWIG_fail;
51980 }
51981 resultobj = SWIG_Py_Void();
51982 return resultobj;
51983 fail:
51984 return NULL;
51985 }
51986
51987
51988 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51989 PyObject *resultobj = 0;
51990 wxSizer *arg1 = (wxSizer *) 0 ;
51991 wxSize result;
51992 void *argp1 = 0 ;
51993 int res1 = 0 ;
51994 PyObject *swig_obj[1] ;
51995
51996 if (!args) SWIG_fail;
51997 swig_obj[0] = args;
51998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51999 if (!SWIG_IsOK(res1)) {
52000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52001 }
52002 arg1 = reinterpret_cast< wxSizer * >(argp1);
52003 {
52004 PyThreadState* __tstate = wxPyBeginAllowThreads();
52005 result = (arg1)->CalcMin();
52006 wxPyEndAllowThreads(__tstate);
52007 if (PyErr_Occurred()) SWIG_fail;
52008 }
52009 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52010 return resultobj;
52011 fail:
52012 return NULL;
52013 }
52014
52015
52016 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52017 PyObject *resultobj = 0;
52018 wxSizer *arg1 = (wxSizer *) 0 ;
52019 void *argp1 = 0 ;
52020 int res1 = 0 ;
52021 PyObject *swig_obj[1] ;
52022
52023 if (!args) SWIG_fail;
52024 swig_obj[0] = args;
52025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52026 if (!SWIG_IsOK(res1)) {
52027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52028 }
52029 arg1 = reinterpret_cast< wxSizer * >(argp1);
52030 {
52031 PyThreadState* __tstate = wxPyBeginAllowThreads();
52032 (arg1)->Layout();
52033 wxPyEndAllowThreads(__tstate);
52034 if (PyErr_Occurred()) SWIG_fail;
52035 }
52036 resultobj = SWIG_Py_Void();
52037 return resultobj;
52038 fail:
52039 return NULL;
52040 }
52041
52042
52043 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52044 PyObject *resultobj = 0;
52045 wxSizer *arg1 = (wxSizer *) 0 ;
52046 wxWindow *arg2 = (wxWindow *) 0 ;
52047 wxSize result;
52048 void *argp1 = 0 ;
52049 int res1 = 0 ;
52050 void *argp2 = 0 ;
52051 int res2 = 0 ;
52052 PyObject * obj0 = 0 ;
52053 PyObject * obj1 = 0 ;
52054 char * kwnames[] = {
52055 (char *) "self",(char *) "window", NULL
52056 };
52057
52058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52060 if (!SWIG_IsOK(res1)) {
52061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52062 }
52063 arg1 = reinterpret_cast< wxSizer * >(argp1);
52064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52065 if (!SWIG_IsOK(res2)) {
52066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52067 }
52068 arg2 = reinterpret_cast< wxWindow * >(argp2);
52069 {
52070 PyThreadState* __tstate = wxPyBeginAllowThreads();
52071 result = (arg1)->Fit(arg2);
52072 wxPyEndAllowThreads(__tstate);
52073 if (PyErr_Occurred()) SWIG_fail;
52074 }
52075 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52076 return resultobj;
52077 fail:
52078 return NULL;
52079 }
52080
52081
52082 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52083 PyObject *resultobj = 0;
52084 wxSizer *arg1 = (wxSizer *) 0 ;
52085 wxWindow *arg2 = (wxWindow *) 0 ;
52086 void *argp1 = 0 ;
52087 int res1 = 0 ;
52088 void *argp2 = 0 ;
52089 int res2 = 0 ;
52090 PyObject * obj0 = 0 ;
52091 PyObject * obj1 = 0 ;
52092 char * kwnames[] = {
52093 (char *) "self",(char *) "window", NULL
52094 };
52095
52096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52098 if (!SWIG_IsOK(res1)) {
52099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52100 }
52101 arg1 = reinterpret_cast< wxSizer * >(argp1);
52102 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52103 if (!SWIG_IsOK(res2)) {
52104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52105 }
52106 arg2 = reinterpret_cast< wxWindow * >(argp2);
52107 {
52108 PyThreadState* __tstate = wxPyBeginAllowThreads();
52109 (arg1)->FitInside(arg2);
52110 wxPyEndAllowThreads(__tstate);
52111 if (PyErr_Occurred()) SWIG_fail;
52112 }
52113 resultobj = SWIG_Py_Void();
52114 return resultobj;
52115 fail:
52116 return NULL;
52117 }
52118
52119
52120 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52121 PyObject *resultobj = 0;
52122 wxSizer *arg1 = (wxSizer *) 0 ;
52123 wxWindow *arg2 = (wxWindow *) 0 ;
52124 void *argp1 = 0 ;
52125 int res1 = 0 ;
52126 void *argp2 = 0 ;
52127 int res2 = 0 ;
52128 PyObject * obj0 = 0 ;
52129 PyObject * obj1 = 0 ;
52130 char * kwnames[] = {
52131 (char *) "self",(char *) "window", NULL
52132 };
52133
52134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52136 if (!SWIG_IsOK(res1)) {
52137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52138 }
52139 arg1 = reinterpret_cast< wxSizer * >(argp1);
52140 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52141 if (!SWIG_IsOK(res2)) {
52142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52143 }
52144 arg2 = reinterpret_cast< wxWindow * >(argp2);
52145 {
52146 PyThreadState* __tstate = wxPyBeginAllowThreads();
52147 (arg1)->SetSizeHints(arg2);
52148 wxPyEndAllowThreads(__tstate);
52149 if (PyErr_Occurred()) SWIG_fail;
52150 }
52151 resultobj = SWIG_Py_Void();
52152 return resultobj;
52153 fail:
52154 return NULL;
52155 }
52156
52157
52158 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52159 PyObject *resultobj = 0;
52160 wxSizer *arg1 = (wxSizer *) 0 ;
52161 wxWindow *arg2 = (wxWindow *) 0 ;
52162 void *argp1 = 0 ;
52163 int res1 = 0 ;
52164 void *argp2 = 0 ;
52165 int res2 = 0 ;
52166 PyObject * obj0 = 0 ;
52167 PyObject * obj1 = 0 ;
52168 char * kwnames[] = {
52169 (char *) "self",(char *) "window", NULL
52170 };
52171
52172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52174 if (!SWIG_IsOK(res1)) {
52175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52176 }
52177 arg1 = reinterpret_cast< wxSizer * >(argp1);
52178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52179 if (!SWIG_IsOK(res2)) {
52180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52181 }
52182 arg2 = reinterpret_cast< wxWindow * >(argp2);
52183 {
52184 PyThreadState* __tstate = wxPyBeginAllowThreads();
52185 (arg1)->SetVirtualSizeHints(arg2);
52186 wxPyEndAllowThreads(__tstate);
52187 if (PyErr_Occurred()) SWIG_fail;
52188 }
52189 resultobj = SWIG_Py_Void();
52190 return resultobj;
52191 fail:
52192 return NULL;
52193 }
52194
52195
52196 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52197 PyObject *resultobj = 0;
52198 wxSizer *arg1 = (wxSizer *) 0 ;
52199 bool arg2 = (bool) false ;
52200 void *argp1 = 0 ;
52201 int res1 = 0 ;
52202 bool val2 ;
52203 int ecode2 = 0 ;
52204 PyObject * obj0 = 0 ;
52205 PyObject * obj1 = 0 ;
52206 char * kwnames[] = {
52207 (char *) "self",(char *) "deleteWindows", NULL
52208 };
52209
52210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52212 if (!SWIG_IsOK(res1)) {
52213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52214 }
52215 arg1 = reinterpret_cast< wxSizer * >(argp1);
52216 if (obj1) {
52217 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52218 if (!SWIG_IsOK(ecode2)) {
52219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52220 }
52221 arg2 = static_cast< bool >(val2);
52222 }
52223 {
52224 PyThreadState* __tstate = wxPyBeginAllowThreads();
52225 (arg1)->Clear(arg2);
52226 wxPyEndAllowThreads(__tstate);
52227 if (PyErr_Occurred()) SWIG_fail;
52228 }
52229 resultobj = SWIG_Py_Void();
52230 return resultobj;
52231 fail:
52232 return NULL;
52233 }
52234
52235
52236 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52237 PyObject *resultobj = 0;
52238 wxSizer *arg1 = (wxSizer *) 0 ;
52239 void *argp1 = 0 ;
52240 int res1 = 0 ;
52241 PyObject *swig_obj[1] ;
52242
52243 if (!args) SWIG_fail;
52244 swig_obj[0] = args;
52245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52246 if (!SWIG_IsOK(res1)) {
52247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52248 }
52249 arg1 = reinterpret_cast< wxSizer * >(argp1);
52250 {
52251 PyThreadState* __tstate = wxPyBeginAllowThreads();
52252 (arg1)->DeleteWindows();
52253 wxPyEndAllowThreads(__tstate);
52254 if (PyErr_Occurred()) SWIG_fail;
52255 }
52256 resultobj = SWIG_Py_Void();
52257 return resultobj;
52258 fail:
52259 return NULL;
52260 }
52261
52262
52263 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52264 PyObject *resultobj = 0;
52265 wxSizer *arg1 = (wxSizer *) 0 ;
52266 PyObject *result = 0 ;
52267 void *argp1 = 0 ;
52268 int res1 = 0 ;
52269 PyObject *swig_obj[1] ;
52270
52271 if (!args) SWIG_fail;
52272 swig_obj[0] = args;
52273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52274 if (!SWIG_IsOK(res1)) {
52275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52276 }
52277 arg1 = reinterpret_cast< wxSizer * >(argp1);
52278 {
52279 PyThreadState* __tstate = wxPyBeginAllowThreads();
52280 result = (PyObject *)wxSizer_GetChildren(arg1);
52281 wxPyEndAllowThreads(__tstate);
52282 if (PyErr_Occurred()) SWIG_fail;
52283 }
52284 resultobj = result;
52285 return resultobj;
52286 fail:
52287 return NULL;
52288 }
52289
52290
52291 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52292 PyObject *resultobj = 0;
52293 wxSizer *arg1 = (wxSizer *) 0 ;
52294 PyObject *arg2 = (PyObject *) 0 ;
52295 bool arg3 = (bool) true ;
52296 bool arg4 = (bool) false ;
52297 bool result;
52298 void *argp1 = 0 ;
52299 int res1 = 0 ;
52300 bool val3 ;
52301 int ecode3 = 0 ;
52302 bool val4 ;
52303 int ecode4 = 0 ;
52304 PyObject * obj0 = 0 ;
52305 PyObject * obj1 = 0 ;
52306 PyObject * obj2 = 0 ;
52307 PyObject * obj3 = 0 ;
52308 char * kwnames[] = {
52309 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52310 };
52311
52312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52314 if (!SWIG_IsOK(res1)) {
52315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52316 }
52317 arg1 = reinterpret_cast< wxSizer * >(argp1);
52318 arg2 = obj1;
52319 if (obj2) {
52320 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52321 if (!SWIG_IsOK(ecode3)) {
52322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52323 }
52324 arg3 = static_cast< bool >(val3);
52325 }
52326 if (obj3) {
52327 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52328 if (!SWIG_IsOK(ecode4)) {
52329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52330 }
52331 arg4 = static_cast< bool >(val4);
52332 }
52333 {
52334 PyThreadState* __tstate = wxPyBeginAllowThreads();
52335 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52336 wxPyEndAllowThreads(__tstate);
52337 if (PyErr_Occurred()) SWIG_fail;
52338 }
52339 {
52340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52341 }
52342 return resultobj;
52343 fail:
52344 return NULL;
52345 }
52346
52347
52348 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52349 PyObject *resultobj = 0;
52350 wxSizer *arg1 = (wxSizer *) 0 ;
52351 PyObject *arg2 = (PyObject *) 0 ;
52352 bool result;
52353 void *argp1 = 0 ;
52354 int res1 = 0 ;
52355 PyObject * obj0 = 0 ;
52356 PyObject * obj1 = 0 ;
52357 char * kwnames[] = {
52358 (char *) "self",(char *) "item", NULL
52359 };
52360
52361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
52362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52363 if (!SWIG_IsOK(res1)) {
52364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
52365 }
52366 arg1 = reinterpret_cast< wxSizer * >(argp1);
52367 arg2 = obj1;
52368 {
52369 PyThreadState* __tstate = wxPyBeginAllowThreads();
52370 result = (bool)wxSizer_IsShown(arg1,arg2);
52371 wxPyEndAllowThreads(__tstate);
52372 if (PyErr_Occurred()) SWIG_fail;
52373 }
52374 {
52375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52376 }
52377 return resultobj;
52378 fail:
52379 return NULL;
52380 }
52381
52382
52383 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52384 PyObject *resultobj = 0;
52385 wxSizer *arg1 = (wxSizer *) 0 ;
52386 bool arg2 ;
52387 void *argp1 = 0 ;
52388 int res1 = 0 ;
52389 bool val2 ;
52390 int ecode2 = 0 ;
52391 PyObject * obj0 = 0 ;
52392 PyObject * obj1 = 0 ;
52393 char * kwnames[] = {
52394 (char *) "self",(char *) "show", NULL
52395 };
52396
52397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
52398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52399 if (!SWIG_IsOK(res1)) {
52400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
52401 }
52402 arg1 = reinterpret_cast< wxSizer * >(argp1);
52403 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52404 if (!SWIG_IsOK(ecode2)) {
52405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
52406 }
52407 arg2 = static_cast< bool >(val2);
52408 {
52409 PyThreadState* __tstate = wxPyBeginAllowThreads();
52410 (arg1)->ShowItems(arg2);
52411 wxPyEndAllowThreads(__tstate);
52412 if (PyErr_Occurred()) SWIG_fail;
52413 }
52414 resultobj = SWIG_Py_Void();
52415 return resultobj;
52416 fail:
52417 return NULL;
52418 }
52419
52420
52421 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52422 PyObject *obj;
52423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52424 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
52425 return SWIG_Py_Void();
52426 }
52427
52428 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52429 PyObject *resultobj = 0;
52430 wxPySizer *result = 0 ;
52431
52432 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
52433 {
52434 PyThreadState* __tstate = wxPyBeginAllowThreads();
52435 result = (wxPySizer *)new wxPySizer();
52436 wxPyEndAllowThreads(__tstate);
52437 if (PyErr_Occurred()) SWIG_fail;
52438 }
52439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
52440 return resultobj;
52441 fail:
52442 return NULL;
52443 }
52444
52445
52446 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52447 PyObject *resultobj = 0;
52448 wxPySizer *arg1 = (wxPySizer *) 0 ;
52449 PyObject *arg2 = (PyObject *) 0 ;
52450 PyObject *arg3 = (PyObject *) 0 ;
52451 void *argp1 = 0 ;
52452 int res1 = 0 ;
52453 PyObject * obj0 = 0 ;
52454 PyObject * obj1 = 0 ;
52455 PyObject * obj2 = 0 ;
52456 char * kwnames[] = {
52457 (char *) "self",(char *) "self",(char *) "_class", NULL
52458 };
52459
52460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
52462 if (!SWIG_IsOK(res1)) {
52463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
52464 }
52465 arg1 = reinterpret_cast< wxPySizer * >(argp1);
52466 arg2 = obj1;
52467 arg3 = obj2;
52468 {
52469 PyThreadState* __tstate = wxPyBeginAllowThreads();
52470 (arg1)->_setCallbackInfo(arg2,arg3);
52471 wxPyEndAllowThreads(__tstate);
52472 if (PyErr_Occurred()) SWIG_fail;
52473 }
52474 resultobj = SWIG_Py_Void();
52475 return resultobj;
52476 fail:
52477 return NULL;
52478 }
52479
52480
52481 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52482 PyObject *obj;
52483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52484 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
52485 return SWIG_Py_Void();
52486 }
52487
52488 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52489 return SWIG_Python_InitShadowInstance(args);
52490 }
52491
52492 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52493 PyObject *resultobj = 0;
52494 int arg1 = (int) wxHORIZONTAL ;
52495 wxBoxSizer *result = 0 ;
52496 int val1 ;
52497 int ecode1 = 0 ;
52498 PyObject * obj0 = 0 ;
52499 char * kwnames[] = {
52500 (char *) "orient", NULL
52501 };
52502
52503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
52504 if (obj0) {
52505 ecode1 = SWIG_AsVal_int(obj0, &val1);
52506 if (!SWIG_IsOK(ecode1)) {
52507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
52508 }
52509 arg1 = static_cast< int >(val1);
52510 }
52511 {
52512 PyThreadState* __tstate = wxPyBeginAllowThreads();
52513 result = (wxBoxSizer *)new wxBoxSizer(arg1);
52514 wxPyEndAllowThreads(__tstate);
52515 if (PyErr_Occurred()) SWIG_fail;
52516 }
52517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
52518 return resultobj;
52519 fail:
52520 return NULL;
52521 }
52522
52523
52524 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52525 PyObject *resultobj = 0;
52526 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52527 int result;
52528 void *argp1 = 0 ;
52529 int res1 = 0 ;
52530 PyObject *swig_obj[1] ;
52531
52532 if (!args) SWIG_fail;
52533 swig_obj[0] = args;
52534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52535 if (!SWIG_IsOK(res1)) {
52536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52537 }
52538 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52539 {
52540 PyThreadState* __tstate = wxPyBeginAllowThreads();
52541 result = (int)(arg1)->GetOrientation();
52542 wxPyEndAllowThreads(__tstate);
52543 if (PyErr_Occurred()) SWIG_fail;
52544 }
52545 resultobj = SWIG_From_int(static_cast< int >(result));
52546 return resultobj;
52547 fail:
52548 return NULL;
52549 }
52550
52551
52552 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52553 PyObject *resultobj = 0;
52554 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52555 int arg2 ;
52556 void *argp1 = 0 ;
52557 int res1 = 0 ;
52558 int val2 ;
52559 int ecode2 = 0 ;
52560 PyObject * obj0 = 0 ;
52561 PyObject * obj1 = 0 ;
52562 char * kwnames[] = {
52563 (char *) "self",(char *) "orient", NULL
52564 };
52565
52566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
52567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52568 if (!SWIG_IsOK(res1)) {
52569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52570 }
52571 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52572 ecode2 = SWIG_AsVal_int(obj1, &val2);
52573 if (!SWIG_IsOK(ecode2)) {
52574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
52575 }
52576 arg2 = static_cast< int >(val2);
52577 {
52578 PyThreadState* __tstate = wxPyBeginAllowThreads();
52579 (arg1)->SetOrientation(arg2);
52580 wxPyEndAllowThreads(__tstate);
52581 if (PyErr_Occurred()) SWIG_fail;
52582 }
52583 resultobj = SWIG_Py_Void();
52584 return resultobj;
52585 fail:
52586 return NULL;
52587 }
52588
52589
52590 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52591 PyObject *obj;
52592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52593 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
52594 return SWIG_Py_Void();
52595 }
52596
52597 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52598 return SWIG_Python_InitShadowInstance(args);
52599 }
52600
52601 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52602 PyObject *resultobj = 0;
52603 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
52604 int arg2 = (int) wxHORIZONTAL ;
52605 wxStaticBoxSizer *result = 0 ;
52606 void *argp1 = 0 ;
52607 int res1 = 0 ;
52608 int val2 ;
52609 int ecode2 = 0 ;
52610 PyObject * obj0 = 0 ;
52611 PyObject * obj1 = 0 ;
52612 char * kwnames[] = {
52613 (char *) "box",(char *) "orient", NULL
52614 };
52615
52616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
52617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
52618 if (!SWIG_IsOK(res1)) {
52619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
52620 }
52621 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
52622 if (obj1) {
52623 ecode2 = SWIG_AsVal_int(obj1, &val2);
52624 if (!SWIG_IsOK(ecode2)) {
52625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
52626 }
52627 arg2 = static_cast< int >(val2);
52628 }
52629 {
52630 PyThreadState* __tstate = wxPyBeginAllowThreads();
52631 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
52632 wxPyEndAllowThreads(__tstate);
52633 if (PyErr_Occurred()) SWIG_fail;
52634 }
52635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
52636 return resultobj;
52637 fail:
52638 return NULL;
52639 }
52640
52641
52642 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52643 PyObject *resultobj = 0;
52644 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
52645 wxStaticBox *result = 0 ;
52646 void *argp1 = 0 ;
52647 int res1 = 0 ;
52648 PyObject *swig_obj[1] ;
52649
52650 if (!args) SWIG_fail;
52651 swig_obj[0] = args;
52652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
52653 if (!SWIG_IsOK(res1)) {
52654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
52655 }
52656 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
52657 {
52658 PyThreadState* __tstate = wxPyBeginAllowThreads();
52659 result = (wxStaticBox *)(arg1)->GetStaticBox();
52660 wxPyEndAllowThreads(__tstate);
52661 if (PyErr_Occurred()) SWIG_fail;
52662 }
52663 {
52664 resultobj = wxPyMake_wxObject(result, (bool)0);
52665 }
52666 return resultobj;
52667 fail:
52668 return NULL;
52669 }
52670
52671
52672 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52673 PyObject *obj;
52674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52675 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
52676 return SWIG_Py_Void();
52677 }
52678
52679 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52680 return SWIG_Python_InitShadowInstance(args);
52681 }
52682
52683 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52684 PyObject *resultobj = 0;
52685 int arg1 = (int) 1 ;
52686 int arg2 = (int) 0 ;
52687 int arg3 = (int) 0 ;
52688 int arg4 = (int) 0 ;
52689 wxGridSizer *result = 0 ;
52690 int val1 ;
52691 int ecode1 = 0 ;
52692 int val2 ;
52693 int ecode2 = 0 ;
52694 int val3 ;
52695 int ecode3 = 0 ;
52696 int val4 ;
52697 int ecode4 = 0 ;
52698 PyObject * obj0 = 0 ;
52699 PyObject * obj1 = 0 ;
52700 PyObject * obj2 = 0 ;
52701 PyObject * obj3 = 0 ;
52702 char * kwnames[] = {
52703 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
52704 };
52705
52706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52707 if (obj0) {
52708 ecode1 = SWIG_AsVal_int(obj0, &val1);
52709 if (!SWIG_IsOK(ecode1)) {
52710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
52711 }
52712 arg1 = static_cast< int >(val1);
52713 }
52714 if (obj1) {
52715 ecode2 = SWIG_AsVal_int(obj1, &val2);
52716 if (!SWIG_IsOK(ecode2)) {
52717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
52718 }
52719 arg2 = static_cast< int >(val2);
52720 }
52721 if (obj2) {
52722 ecode3 = SWIG_AsVal_int(obj2, &val3);
52723 if (!SWIG_IsOK(ecode3)) {
52724 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
52725 }
52726 arg3 = static_cast< int >(val3);
52727 }
52728 if (obj3) {
52729 ecode4 = SWIG_AsVal_int(obj3, &val4);
52730 if (!SWIG_IsOK(ecode4)) {
52731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
52732 }
52733 arg4 = static_cast< int >(val4);
52734 }
52735 {
52736 PyThreadState* __tstate = wxPyBeginAllowThreads();
52737 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
52738 wxPyEndAllowThreads(__tstate);
52739 if (PyErr_Occurred()) SWIG_fail;
52740 }
52741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
52742 return resultobj;
52743 fail:
52744 return NULL;
52745 }
52746
52747
52748 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52749 PyObject *resultobj = 0;
52750 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52751 int arg2 ;
52752 void *argp1 = 0 ;
52753 int res1 = 0 ;
52754 int val2 ;
52755 int ecode2 = 0 ;
52756 PyObject * obj0 = 0 ;
52757 PyObject * obj1 = 0 ;
52758 char * kwnames[] = {
52759 (char *) "self",(char *) "cols", NULL
52760 };
52761
52762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
52763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52764 if (!SWIG_IsOK(res1)) {
52765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52766 }
52767 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52768 ecode2 = SWIG_AsVal_int(obj1, &val2);
52769 if (!SWIG_IsOK(ecode2)) {
52770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
52771 }
52772 arg2 = static_cast< int >(val2);
52773 {
52774 PyThreadState* __tstate = wxPyBeginAllowThreads();
52775 (arg1)->SetCols(arg2);
52776 wxPyEndAllowThreads(__tstate);
52777 if (PyErr_Occurred()) SWIG_fail;
52778 }
52779 resultobj = SWIG_Py_Void();
52780 return resultobj;
52781 fail:
52782 return NULL;
52783 }
52784
52785
52786 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52787 PyObject *resultobj = 0;
52788 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52789 int arg2 ;
52790 void *argp1 = 0 ;
52791 int res1 = 0 ;
52792 int val2 ;
52793 int ecode2 = 0 ;
52794 PyObject * obj0 = 0 ;
52795 PyObject * obj1 = 0 ;
52796 char * kwnames[] = {
52797 (char *) "self",(char *) "rows", NULL
52798 };
52799
52800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
52801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52802 if (!SWIG_IsOK(res1)) {
52803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52804 }
52805 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52806 ecode2 = SWIG_AsVal_int(obj1, &val2);
52807 if (!SWIG_IsOK(ecode2)) {
52808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
52809 }
52810 arg2 = static_cast< int >(val2);
52811 {
52812 PyThreadState* __tstate = wxPyBeginAllowThreads();
52813 (arg1)->SetRows(arg2);
52814 wxPyEndAllowThreads(__tstate);
52815 if (PyErr_Occurred()) SWIG_fail;
52816 }
52817 resultobj = SWIG_Py_Void();
52818 return resultobj;
52819 fail:
52820 return NULL;
52821 }
52822
52823
52824 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52825 PyObject *resultobj = 0;
52826 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52827 int arg2 ;
52828 void *argp1 = 0 ;
52829 int res1 = 0 ;
52830 int val2 ;
52831 int ecode2 = 0 ;
52832 PyObject * obj0 = 0 ;
52833 PyObject * obj1 = 0 ;
52834 char * kwnames[] = {
52835 (char *) "self",(char *) "gap", NULL
52836 };
52837
52838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
52839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52840 if (!SWIG_IsOK(res1)) {
52841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52842 }
52843 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52844 ecode2 = SWIG_AsVal_int(obj1, &val2);
52845 if (!SWIG_IsOK(ecode2)) {
52846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
52847 }
52848 arg2 = static_cast< int >(val2);
52849 {
52850 PyThreadState* __tstate = wxPyBeginAllowThreads();
52851 (arg1)->SetVGap(arg2);
52852 wxPyEndAllowThreads(__tstate);
52853 if (PyErr_Occurred()) SWIG_fail;
52854 }
52855 resultobj = SWIG_Py_Void();
52856 return resultobj;
52857 fail:
52858 return NULL;
52859 }
52860
52861
52862 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52863 PyObject *resultobj = 0;
52864 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52865 int arg2 ;
52866 void *argp1 = 0 ;
52867 int res1 = 0 ;
52868 int val2 ;
52869 int ecode2 = 0 ;
52870 PyObject * obj0 = 0 ;
52871 PyObject * obj1 = 0 ;
52872 char * kwnames[] = {
52873 (char *) "self",(char *) "gap", NULL
52874 };
52875
52876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
52877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52878 if (!SWIG_IsOK(res1)) {
52879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52880 }
52881 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52882 ecode2 = SWIG_AsVal_int(obj1, &val2);
52883 if (!SWIG_IsOK(ecode2)) {
52884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
52885 }
52886 arg2 = static_cast< int >(val2);
52887 {
52888 PyThreadState* __tstate = wxPyBeginAllowThreads();
52889 (arg1)->SetHGap(arg2);
52890 wxPyEndAllowThreads(__tstate);
52891 if (PyErr_Occurred()) SWIG_fail;
52892 }
52893 resultobj = SWIG_Py_Void();
52894 return resultobj;
52895 fail:
52896 return NULL;
52897 }
52898
52899
52900 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52901 PyObject *resultobj = 0;
52902 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52903 int result;
52904 void *argp1 = 0 ;
52905 int res1 = 0 ;
52906 PyObject *swig_obj[1] ;
52907
52908 if (!args) SWIG_fail;
52909 swig_obj[0] = args;
52910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52911 if (!SWIG_IsOK(res1)) {
52912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52913 }
52914 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52915 {
52916 PyThreadState* __tstate = wxPyBeginAllowThreads();
52917 result = (int)(arg1)->GetCols();
52918 wxPyEndAllowThreads(__tstate);
52919 if (PyErr_Occurred()) SWIG_fail;
52920 }
52921 resultobj = SWIG_From_int(static_cast< int >(result));
52922 return resultobj;
52923 fail:
52924 return NULL;
52925 }
52926
52927
52928 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52929 PyObject *resultobj = 0;
52930 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52931 int result;
52932 void *argp1 = 0 ;
52933 int res1 = 0 ;
52934 PyObject *swig_obj[1] ;
52935
52936 if (!args) SWIG_fail;
52937 swig_obj[0] = args;
52938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52939 if (!SWIG_IsOK(res1)) {
52940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52941 }
52942 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52943 {
52944 PyThreadState* __tstate = wxPyBeginAllowThreads();
52945 result = (int)(arg1)->GetRows();
52946 wxPyEndAllowThreads(__tstate);
52947 if (PyErr_Occurred()) SWIG_fail;
52948 }
52949 resultobj = SWIG_From_int(static_cast< int >(result));
52950 return resultobj;
52951 fail:
52952 return NULL;
52953 }
52954
52955
52956 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52957 PyObject *resultobj = 0;
52958 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52959 int result;
52960 void *argp1 = 0 ;
52961 int res1 = 0 ;
52962 PyObject *swig_obj[1] ;
52963
52964 if (!args) SWIG_fail;
52965 swig_obj[0] = args;
52966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52967 if (!SWIG_IsOK(res1)) {
52968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52969 }
52970 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52971 {
52972 PyThreadState* __tstate = wxPyBeginAllowThreads();
52973 result = (int)(arg1)->GetVGap();
52974 wxPyEndAllowThreads(__tstate);
52975 if (PyErr_Occurred()) SWIG_fail;
52976 }
52977 resultobj = SWIG_From_int(static_cast< int >(result));
52978 return resultobj;
52979 fail:
52980 return NULL;
52981 }
52982
52983
52984 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52985 PyObject *resultobj = 0;
52986 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52987 int result;
52988 void *argp1 = 0 ;
52989 int res1 = 0 ;
52990 PyObject *swig_obj[1] ;
52991
52992 if (!args) SWIG_fail;
52993 swig_obj[0] = args;
52994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52995 if (!SWIG_IsOK(res1)) {
52996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52997 }
52998 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52999 {
53000 PyThreadState* __tstate = wxPyBeginAllowThreads();
53001 result = (int)(arg1)->GetHGap();
53002 wxPyEndAllowThreads(__tstate);
53003 if (PyErr_Occurred()) SWIG_fail;
53004 }
53005 resultobj = SWIG_From_int(static_cast< int >(result));
53006 return resultobj;
53007 fail:
53008 return NULL;
53009 }
53010
53011
53012 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53013 PyObject *obj;
53014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53015 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53016 return SWIG_Py_Void();
53017 }
53018
53019 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53020 return SWIG_Python_InitShadowInstance(args);
53021 }
53022
53023 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53024 PyObject *resultobj = 0;
53025 int arg1 = (int) 1 ;
53026 int arg2 = (int) 0 ;
53027 int arg3 = (int) 0 ;
53028 int arg4 = (int) 0 ;
53029 wxFlexGridSizer *result = 0 ;
53030 int val1 ;
53031 int ecode1 = 0 ;
53032 int val2 ;
53033 int ecode2 = 0 ;
53034 int val3 ;
53035 int ecode3 = 0 ;
53036 int val4 ;
53037 int ecode4 = 0 ;
53038 PyObject * obj0 = 0 ;
53039 PyObject * obj1 = 0 ;
53040 PyObject * obj2 = 0 ;
53041 PyObject * obj3 = 0 ;
53042 char * kwnames[] = {
53043 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53044 };
53045
53046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53047 if (obj0) {
53048 ecode1 = SWIG_AsVal_int(obj0, &val1);
53049 if (!SWIG_IsOK(ecode1)) {
53050 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53051 }
53052 arg1 = static_cast< int >(val1);
53053 }
53054 if (obj1) {
53055 ecode2 = SWIG_AsVal_int(obj1, &val2);
53056 if (!SWIG_IsOK(ecode2)) {
53057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53058 }
53059 arg2 = static_cast< int >(val2);
53060 }
53061 if (obj2) {
53062 ecode3 = SWIG_AsVal_int(obj2, &val3);
53063 if (!SWIG_IsOK(ecode3)) {
53064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53065 }
53066 arg3 = static_cast< int >(val3);
53067 }
53068 if (obj3) {
53069 ecode4 = SWIG_AsVal_int(obj3, &val4);
53070 if (!SWIG_IsOK(ecode4)) {
53071 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53072 }
53073 arg4 = static_cast< int >(val4);
53074 }
53075 {
53076 PyThreadState* __tstate = wxPyBeginAllowThreads();
53077 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53078 wxPyEndAllowThreads(__tstate);
53079 if (PyErr_Occurred()) SWIG_fail;
53080 }
53081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53082 return resultobj;
53083 fail:
53084 return NULL;
53085 }
53086
53087
53088 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53089 PyObject *resultobj = 0;
53090 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53091 size_t arg2 ;
53092 int arg3 = (int) 0 ;
53093 void *argp1 = 0 ;
53094 int res1 = 0 ;
53095 size_t val2 ;
53096 int ecode2 = 0 ;
53097 int val3 ;
53098 int ecode3 = 0 ;
53099 PyObject * obj0 = 0 ;
53100 PyObject * obj1 = 0 ;
53101 PyObject * obj2 = 0 ;
53102 char * kwnames[] = {
53103 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53104 };
53105
53106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53108 if (!SWIG_IsOK(res1)) {
53109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53110 }
53111 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53112 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53113 if (!SWIG_IsOK(ecode2)) {
53114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53115 }
53116 arg2 = static_cast< size_t >(val2);
53117 if (obj2) {
53118 ecode3 = SWIG_AsVal_int(obj2, &val3);
53119 if (!SWIG_IsOK(ecode3)) {
53120 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53121 }
53122 arg3 = static_cast< int >(val3);
53123 }
53124 {
53125 PyThreadState* __tstate = wxPyBeginAllowThreads();
53126 (arg1)->AddGrowableRow(arg2,arg3);
53127 wxPyEndAllowThreads(__tstate);
53128 if (PyErr_Occurred()) SWIG_fail;
53129 }
53130 resultobj = SWIG_Py_Void();
53131 return resultobj;
53132 fail:
53133 return NULL;
53134 }
53135
53136
53137 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53138 PyObject *resultobj = 0;
53139 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53140 size_t arg2 ;
53141 void *argp1 = 0 ;
53142 int res1 = 0 ;
53143 size_t val2 ;
53144 int ecode2 = 0 ;
53145 PyObject * obj0 = 0 ;
53146 PyObject * obj1 = 0 ;
53147 char * kwnames[] = {
53148 (char *) "self",(char *) "idx", NULL
53149 };
53150
53151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53153 if (!SWIG_IsOK(res1)) {
53154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53155 }
53156 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53157 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53158 if (!SWIG_IsOK(ecode2)) {
53159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53160 }
53161 arg2 = static_cast< size_t >(val2);
53162 {
53163 PyThreadState* __tstate = wxPyBeginAllowThreads();
53164 (arg1)->RemoveGrowableRow(arg2);
53165 wxPyEndAllowThreads(__tstate);
53166 if (PyErr_Occurred()) SWIG_fail;
53167 }
53168 resultobj = SWIG_Py_Void();
53169 return resultobj;
53170 fail:
53171 return NULL;
53172 }
53173
53174
53175 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53176 PyObject *resultobj = 0;
53177 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53178 size_t arg2 ;
53179 int arg3 = (int) 0 ;
53180 void *argp1 = 0 ;
53181 int res1 = 0 ;
53182 size_t val2 ;
53183 int ecode2 = 0 ;
53184 int val3 ;
53185 int ecode3 = 0 ;
53186 PyObject * obj0 = 0 ;
53187 PyObject * obj1 = 0 ;
53188 PyObject * obj2 = 0 ;
53189 char * kwnames[] = {
53190 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53191 };
53192
53193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53195 if (!SWIG_IsOK(res1)) {
53196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53197 }
53198 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53199 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53200 if (!SWIG_IsOK(ecode2)) {
53201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53202 }
53203 arg2 = static_cast< size_t >(val2);
53204 if (obj2) {
53205 ecode3 = SWIG_AsVal_int(obj2, &val3);
53206 if (!SWIG_IsOK(ecode3)) {
53207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53208 }
53209 arg3 = static_cast< int >(val3);
53210 }
53211 {
53212 PyThreadState* __tstate = wxPyBeginAllowThreads();
53213 (arg1)->AddGrowableCol(arg2,arg3);
53214 wxPyEndAllowThreads(__tstate);
53215 if (PyErr_Occurred()) SWIG_fail;
53216 }
53217 resultobj = SWIG_Py_Void();
53218 return resultobj;
53219 fail:
53220 return NULL;
53221 }
53222
53223
53224 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53225 PyObject *resultobj = 0;
53226 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53227 size_t arg2 ;
53228 void *argp1 = 0 ;
53229 int res1 = 0 ;
53230 size_t val2 ;
53231 int ecode2 = 0 ;
53232 PyObject * obj0 = 0 ;
53233 PyObject * obj1 = 0 ;
53234 char * kwnames[] = {
53235 (char *) "self",(char *) "idx", NULL
53236 };
53237
53238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53240 if (!SWIG_IsOK(res1)) {
53241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53242 }
53243 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53244 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53245 if (!SWIG_IsOK(ecode2)) {
53246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53247 }
53248 arg2 = static_cast< size_t >(val2);
53249 {
53250 PyThreadState* __tstate = wxPyBeginAllowThreads();
53251 (arg1)->RemoveGrowableCol(arg2);
53252 wxPyEndAllowThreads(__tstate);
53253 if (PyErr_Occurred()) SWIG_fail;
53254 }
53255 resultobj = SWIG_Py_Void();
53256 return resultobj;
53257 fail:
53258 return NULL;
53259 }
53260
53261
53262 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53263 PyObject *resultobj = 0;
53264 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53265 int arg2 ;
53266 void *argp1 = 0 ;
53267 int res1 = 0 ;
53268 int val2 ;
53269 int ecode2 = 0 ;
53270 PyObject * obj0 = 0 ;
53271 PyObject * obj1 = 0 ;
53272 char * kwnames[] = {
53273 (char *) "self",(char *) "direction", NULL
53274 };
53275
53276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53278 if (!SWIG_IsOK(res1)) {
53279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53280 }
53281 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53282 ecode2 = SWIG_AsVal_int(obj1, &val2);
53283 if (!SWIG_IsOK(ecode2)) {
53284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53285 }
53286 arg2 = static_cast< int >(val2);
53287 {
53288 PyThreadState* __tstate = wxPyBeginAllowThreads();
53289 (arg1)->SetFlexibleDirection(arg2);
53290 wxPyEndAllowThreads(__tstate);
53291 if (PyErr_Occurred()) SWIG_fail;
53292 }
53293 resultobj = SWIG_Py_Void();
53294 return resultobj;
53295 fail:
53296 return NULL;
53297 }
53298
53299
53300 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53301 PyObject *resultobj = 0;
53302 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53303 int result;
53304 void *argp1 = 0 ;
53305 int res1 = 0 ;
53306 PyObject *swig_obj[1] ;
53307
53308 if (!args) SWIG_fail;
53309 swig_obj[0] = args;
53310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53311 if (!SWIG_IsOK(res1)) {
53312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53313 }
53314 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53315 {
53316 PyThreadState* __tstate = wxPyBeginAllowThreads();
53317 result = (int)(arg1)->GetFlexibleDirection();
53318 wxPyEndAllowThreads(__tstate);
53319 if (PyErr_Occurred()) SWIG_fail;
53320 }
53321 resultobj = SWIG_From_int(static_cast< int >(result));
53322 return resultobj;
53323 fail:
53324 return NULL;
53325 }
53326
53327
53328 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53329 PyObject *resultobj = 0;
53330 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53331 wxFlexSizerGrowMode arg2 ;
53332 void *argp1 = 0 ;
53333 int res1 = 0 ;
53334 int val2 ;
53335 int ecode2 = 0 ;
53336 PyObject * obj0 = 0 ;
53337 PyObject * obj1 = 0 ;
53338 char * kwnames[] = {
53339 (char *) "self",(char *) "mode", NULL
53340 };
53341
53342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53344 if (!SWIG_IsOK(res1)) {
53345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53346 }
53347 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53348 ecode2 = SWIG_AsVal_int(obj1, &val2);
53349 if (!SWIG_IsOK(ecode2)) {
53350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
53351 }
53352 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
53353 {
53354 PyThreadState* __tstate = wxPyBeginAllowThreads();
53355 (arg1)->SetNonFlexibleGrowMode(arg2);
53356 wxPyEndAllowThreads(__tstate);
53357 if (PyErr_Occurred()) SWIG_fail;
53358 }
53359 resultobj = SWIG_Py_Void();
53360 return resultobj;
53361 fail:
53362 return NULL;
53363 }
53364
53365
53366 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53367 PyObject *resultobj = 0;
53368 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53369 wxFlexSizerGrowMode result;
53370 void *argp1 = 0 ;
53371 int res1 = 0 ;
53372 PyObject *swig_obj[1] ;
53373
53374 if (!args) SWIG_fail;
53375 swig_obj[0] = args;
53376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53377 if (!SWIG_IsOK(res1)) {
53378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53379 }
53380 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53381 {
53382 PyThreadState* __tstate = wxPyBeginAllowThreads();
53383 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
53384 wxPyEndAllowThreads(__tstate);
53385 if (PyErr_Occurred()) SWIG_fail;
53386 }
53387 resultobj = SWIG_From_int(static_cast< int >(result));
53388 return resultobj;
53389 fail:
53390 return NULL;
53391 }
53392
53393
53394 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53395 PyObject *resultobj = 0;
53396 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53397 wxArrayInt *result = 0 ;
53398 void *argp1 = 0 ;
53399 int res1 = 0 ;
53400 PyObject *swig_obj[1] ;
53401
53402 if (!args) SWIG_fail;
53403 swig_obj[0] = args;
53404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53405 if (!SWIG_IsOK(res1)) {
53406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53407 }
53408 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53409 {
53410 PyThreadState* __tstate = wxPyBeginAllowThreads();
53411 {
53412 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
53413 result = (wxArrayInt *) &_result_ref;
53414 }
53415 wxPyEndAllowThreads(__tstate);
53416 if (PyErr_Occurred()) SWIG_fail;
53417 }
53418 {
53419 resultobj = wxArrayInt2PyList_helper(*result);
53420 }
53421 return resultobj;
53422 fail:
53423 return NULL;
53424 }
53425
53426
53427 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53428 PyObject *resultobj = 0;
53429 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53430 wxArrayInt *result = 0 ;
53431 void *argp1 = 0 ;
53432 int res1 = 0 ;
53433 PyObject *swig_obj[1] ;
53434
53435 if (!args) SWIG_fail;
53436 swig_obj[0] = args;
53437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53438 if (!SWIG_IsOK(res1)) {
53439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53440 }
53441 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53442 {
53443 PyThreadState* __tstate = wxPyBeginAllowThreads();
53444 {
53445 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
53446 result = (wxArrayInt *) &_result_ref;
53447 }
53448 wxPyEndAllowThreads(__tstate);
53449 if (PyErr_Occurred()) SWIG_fail;
53450 }
53451 {
53452 resultobj = wxArrayInt2PyList_helper(*result);
53453 }
53454 return resultobj;
53455 fail:
53456 return NULL;
53457 }
53458
53459
53460 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53461 PyObject *obj;
53462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53463 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
53464 return SWIG_Py_Void();
53465 }
53466
53467 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53468 return SWIG_Python_InitShadowInstance(args);
53469 }
53470
53471 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53472 PyObject *resultobj = 0;
53473 wxStdDialogButtonSizer *result = 0 ;
53474
53475 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
53476 {
53477 PyThreadState* __tstate = wxPyBeginAllowThreads();
53478 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
53479 wxPyEndAllowThreads(__tstate);
53480 if (PyErr_Occurred()) SWIG_fail;
53481 }
53482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
53483 return resultobj;
53484 fail:
53485 return NULL;
53486 }
53487
53488
53489 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53490 PyObject *resultobj = 0;
53491 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53492 wxButton *arg2 = (wxButton *) 0 ;
53493 void *argp1 = 0 ;
53494 int res1 = 0 ;
53495 void *argp2 = 0 ;
53496 int res2 = 0 ;
53497 PyObject * obj0 = 0 ;
53498 PyObject * obj1 = 0 ;
53499 char * kwnames[] = {
53500 (char *) "self",(char *) "button", NULL
53501 };
53502
53503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
53504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53505 if (!SWIG_IsOK(res1)) {
53506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53507 }
53508 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53510 if (!SWIG_IsOK(res2)) {
53511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
53512 }
53513 arg2 = reinterpret_cast< wxButton * >(argp2);
53514 {
53515 PyThreadState* __tstate = wxPyBeginAllowThreads();
53516 (arg1)->AddButton(arg2);
53517 wxPyEndAllowThreads(__tstate);
53518 if (PyErr_Occurred()) SWIG_fail;
53519 }
53520 resultobj = SWIG_Py_Void();
53521 return resultobj;
53522 fail:
53523 return NULL;
53524 }
53525
53526
53527 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53528 PyObject *resultobj = 0;
53529 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53530 void *argp1 = 0 ;
53531 int res1 = 0 ;
53532 PyObject *swig_obj[1] ;
53533
53534 if (!args) SWIG_fail;
53535 swig_obj[0] = args;
53536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53537 if (!SWIG_IsOK(res1)) {
53538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53539 }
53540 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53541 {
53542 PyThreadState* __tstate = wxPyBeginAllowThreads();
53543 (arg1)->Realize();
53544 wxPyEndAllowThreads(__tstate);
53545 if (PyErr_Occurred()) SWIG_fail;
53546 }
53547 resultobj = SWIG_Py_Void();
53548 return resultobj;
53549 fail:
53550 return NULL;
53551 }
53552
53553
53554 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53555 PyObject *resultobj = 0;
53556 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53557 wxButton *arg2 = (wxButton *) 0 ;
53558 void *argp1 = 0 ;
53559 int res1 = 0 ;
53560 void *argp2 = 0 ;
53561 int res2 = 0 ;
53562 PyObject * obj0 = 0 ;
53563 PyObject * obj1 = 0 ;
53564 char * kwnames[] = {
53565 (char *) "self",(char *) "button", NULL
53566 };
53567
53568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53570 if (!SWIG_IsOK(res1)) {
53571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53572 }
53573 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53575 if (!SWIG_IsOK(res2)) {
53576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53577 }
53578 arg2 = reinterpret_cast< wxButton * >(argp2);
53579 {
53580 PyThreadState* __tstate = wxPyBeginAllowThreads();
53581 (arg1)->SetAffirmativeButton(arg2);
53582 wxPyEndAllowThreads(__tstate);
53583 if (PyErr_Occurred()) SWIG_fail;
53584 }
53585 resultobj = SWIG_Py_Void();
53586 return resultobj;
53587 fail:
53588 return NULL;
53589 }
53590
53591
53592 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53593 PyObject *resultobj = 0;
53594 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53595 wxButton *arg2 = (wxButton *) 0 ;
53596 void *argp1 = 0 ;
53597 int res1 = 0 ;
53598 void *argp2 = 0 ;
53599 int res2 = 0 ;
53600 PyObject * obj0 = 0 ;
53601 PyObject * obj1 = 0 ;
53602 char * kwnames[] = {
53603 (char *) "self",(char *) "button", NULL
53604 };
53605
53606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53608 if (!SWIG_IsOK(res1)) {
53609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53610 }
53611 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53613 if (!SWIG_IsOK(res2)) {
53614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53615 }
53616 arg2 = reinterpret_cast< wxButton * >(argp2);
53617 {
53618 PyThreadState* __tstate = wxPyBeginAllowThreads();
53619 (arg1)->SetNegativeButton(arg2);
53620 wxPyEndAllowThreads(__tstate);
53621 if (PyErr_Occurred()) SWIG_fail;
53622 }
53623 resultobj = SWIG_Py_Void();
53624 return resultobj;
53625 fail:
53626 return NULL;
53627 }
53628
53629
53630 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53631 PyObject *resultobj = 0;
53632 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53633 wxButton *arg2 = (wxButton *) 0 ;
53634 void *argp1 = 0 ;
53635 int res1 = 0 ;
53636 void *argp2 = 0 ;
53637 int res2 = 0 ;
53638 PyObject * obj0 = 0 ;
53639 PyObject * obj1 = 0 ;
53640 char * kwnames[] = {
53641 (char *) "self",(char *) "button", NULL
53642 };
53643
53644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
53645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53646 if (!SWIG_IsOK(res1)) {
53647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53648 }
53649 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53651 if (!SWIG_IsOK(res2)) {
53652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
53653 }
53654 arg2 = reinterpret_cast< wxButton * >(argp2);
53655 {
53656 PyThreadState* __tstate = wxPyBeginAllowThreads();
53657 (arg1)->SetCancelButton(arg2);
53658 wxPyEndAllowThreads(__tstate);
53659 if (PyErr_Occurred()) SWIG_fail;
53660 }
53661 resultobj = SWIG_Py_Void();
53662 return resultobj;
53663 fail:
53664 return NULL;
53665 }
53666
53667
53668 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53669 PyObject *resultobj = 0;
53670 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53671 wxButton *result = 0 ;
53672 void *argp1 = 0 ;
53673 int res1 = 0 ;
53674 PyObject *swig_obj[1] ;
53675
53676 if (!args) SWIG_fail;
53677 swig_obj[0] = args;
53678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53679 if (!SWIG_IsOK(res1)) {
53680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53681 }
53682 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53683 {
53684 PyThreadState* __tstate = wxPyBeginAllowThreads();
53685 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
53686 wxPyEndAllowThreads(__tstate);
53687 if (PyErr_Occurred()) SWIG_fail;
53688 }
53689 {
53690 resultobj = wxPyMake_wxObject(result, (bool)0);
53691 }
53692 return resultobj;
53693 fail:
53694 return NULL;
53695 }
53696
53697
53698 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53699 PyObject *resultobj = 0;
53700 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53701 wxButton *result = 0 ;
53702 void *argp1 = 0 ;
53703 int res1 = 0 ;
53704 PyObject *swig_obj[1] ;
53705
53706 if (!args) SWIG_fail;
53707 swig_obj[0] = args;
53708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53709 if (!SWIG_IsOK(res1)) {
53710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53711 }
53712 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53713 {
53714 PyThreadState* __tstate = wxPyBeginAllowThreads();
53715 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
53716 wxPyEndAllowThreads(__tstate);
53717 if (PyErr_Occurred()) SWIG_fail;
53718 }
53719 {
53720 resultobj = wxPyMake_wxObject(result, (bool)0);
53721 }
53722 return resultobj;
53723 fail:
53724 return NULL;
53725 }
53726
53727
53728 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53729 PyObject *resultobj = 0;
53730 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53731 wxButton *result = 0 ;
53732 void *argp1 = 0 ;
53733 int res1 = 0 ;
53734 PyObject *swig_obj[1] ;
53735
53736 if (!args) SWIG_fail;
53737 swig_obj[0] = args;
53738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53739 if (!SWIG_IsOK(res1)) {
53740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53741 }
53742 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53743 {
53744 PyThreadState* __tstate = wxPyBeginAllowThreads();
53745 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
53746 wxPyEndAllowThreads(__tstate);
53747 if (PyErr_Occurred()) SWIG_fail;
53748 }
53749 {
53750 resultobj = wxPyMake_wxObject(result, (bool)0);
53751 }
53752 return resultobj;
53753 fail:
53754 return NULL;
53755 }
53756
53757
53758 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53759 PyObject *resultobj = 0;
53760 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53761 wxButton *result = 0 ;
53762 void *argp1 = 0 ;
53763 int res1 = 0 ;
53764 PyObject *swig_obj[1] ;
53765
53766 if (!args) SWIG_fail;
53767 swig_obj[0] = args;
53768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53769 if (!SWIG_IsOK(res1)) {
53770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53771 }
53772 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53773 {
53774 PyThreadState* __tstate = wxPyBeginAllowThreads();
53775 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
53776 wxPyEndAllowThreads(__tstate);
53777 if (PyErr_Occurred()) SWIG_fail;
53778 }
53779 {
53780 resultobj = wxPyMake_wxObject(result, (bool)0);
53781 }
53782 return resultobj;
53783 fail:
53784 return NULL;
53785 }
53786
53787
53788 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53789 PyObject *resultobj = 0;
53790 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53791 wxButton *result = 0 ;
53792 void *argp1 = 0 ;
53793 int res1 = 0 ;
53794 PyObject *swig_obj[1] ;
53795
53796 if (!args) SWIG_fail;
53797 swig_obj[0] = args;
53798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53799 if (!SWIG_IsOK(res1)) {
53800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53801 }
53802 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53803 {
53804 PyThreadState* __tstate = wxPyBeginAllowThreads();
53805 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
53806 wxPyEndAllowThreads(__tstate);
53807 if (PyErr_Occurred()) SWIG_fail;
53808 }
53809 {
53810 resultobj = wxPyMake_wxObject(result, (bool)0);
53811 }
53812 return resultobj;
53813 fail:
53814 return NULL;
53815 }
53816
53817
53818 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53819 PyObject *obj;
53820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53821 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
53822 return SWIG_Py_Void();
53823 }
53824
53825 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53826 return SWIG_Python_InitShadowInstance(args);
53827 }
53828
53829 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53830 PyObject *resultobj = 0;
53831 int arg1 = (int) 0 ;
53832 int arg2 = (int) 0 ;
53833 wxGBPosition *result = 0 ;
53834 int val1 ;
53835 int ecode1 = 0 ;
53836 int val2 ;
53837 int ecode2 = 0 ;
53838 PyObject * obj0 = 0 ;
53839 PyObject * obj1 = 0 ;
53840 char * kwnames[] = {
53841 (char *) "row",(char *) "col", NULL
53842 };
53843
53844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
53845 if (obj0) {
53846 ecode1 = SWIG_AsVal_int(obj0, &val1);
53847 if (!SWIG_IsOK(ecode1)) {
53848 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
53849 }
53850 arg1 = static_cast< int >(val1);
53851 }
53852 if (obj1) {
53853 ecode2 = SWIG_AsVal_int(obj1, &val2);
53854 if (!SWIG_IsOK(ecode2)) {
53855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
53856 }
53857 arg2 = static_cast< int >(val2);
53858 }
53859 {
53860 PyThreadState* __tstate = wxPyBeginAllowThreads();
53861 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
53862 wxPyEndAllowThreads(__tstate);
53863 if (PyErr_Occurred()) SWIG_fail;
53864 }
53865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
53866 return resultobj;
53867 fail:
53868 return NULL;
53869 }
53870
53871
53872 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53873 PyObject *resultobj = 0;
53874 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53875 void *argp1 = 0 ;
53876 int res1 = 0 ;
53877 PyObject *swig_obj[1] ;
53878
53879 if (!args) SWIG_fail;
53880 swig_obj[0] = args;
53881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
53882 if (!SWIG_IsOK(res1)) {
53883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53884 }
53885 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53886 {
53887 PyThreadState* __tstate = wxPyBeginAllowThreads();
53888 delete arg1;
53889
53890 wxPyEndAllowThreads(__tstate);
53891 if (PyErr_Occurred()) SWIG_fail;
53892 }
53893 resultobj = SWIG_Py_Void();
53894 return resultobj;
53895 fail:
53896 return NULL;
53897 }
53898
53899
53900 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53901 PyObject *resultobj = 0;
53902 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53903 int result;
53904 void *argp1 = 0 ;
53905 int res1 = 0 ;
53906 PyObject *swig_obj[1] ;
53907
53908 if (!args) SWIG_fail;
53909 swig_obj[0] = args;
53910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53911 if (!SWIG_IsOK(res1)) {
53912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
53913 }
53914 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53915 {
53916 PyThreadState* __tstate = wxPyBeginAllowThreads();
53917 result = (int)((wxGBPosition const *)arg1)->GetRow();
53918 wxPyEndAllowThreads(__tstate);
53919 if (PyErr_Occurred()) SWIG_fail;
53920 }
53921 resultobj = SWIG_From_int(static_cast< int >(result));
53922 return resultobj;
53923 fail:
53924 return NULL;
53925 }
53926
53927
53928 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53929 PyObject *resultobj = 0;
53930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53931 int result;
53932 void *argp1 = 0 ;
53933 int res1 = 0 ;
53934 PyObject *swig_obj[1] ;
53935
53936 if (!args) SWIG_fail;
53937 swig_obj[0] = args;
53938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53939 if (!SWIG_IsOK(res1)) {
53940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
53941 }
53942 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53943 {
53944 PyThreadState* __tstate = wxPyBeginAllowThreads();
53945 result = (int)((wxGBPosition const *)arg1)->GetCol();
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 *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53957 PyObject *resultobj = 0;
53958 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53959 int arg2 ;
53960 void *argp1 = 0 ;
53961 int res1 = 0 ;
53962 int val2 ;
53963 int ecode2 = 0 ;
53964 PyObject * obj0 = 0 ;
53965 PyObject * obj1 = 0 ;
53966 char * kwnames[] = {
53967 (char *) "self",(char *) "row", NULL
53968 };
53969
53970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
53971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53972 if (!SWIG_IsOK(res1)) {
53973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53974 }
53975 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53976 ecode2 = SWIG_AsVal_int(obj1, &val2);
53977 if (!SWIG_IsOK(ecode2)) {
53978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
53979 }
53980 arg2 = static_cast< int >(val2);
53981 {
53982 PyThreadState* __tstate = wxPyBeginAllowThreads();
53983 (arg1)->SetRow(arg2);
53984 wxPyEndAllowThreads(__tstate);
53985 if (PyErr_Occurred()) SWIG_fail;
53986 }
53987 resultobj = SWIG_Py_Void();
53988 return resultobj;
53989 fail:
53990 return NULL;
53991 }
53992
53993
53994 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53995 PyObject *resultobj = 0;
53996 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53997 int arg2 ;
53998 void *argp1 = 0 ;
53999 int res1 = 0 ;
54000 int val2 ;
54001 int ecode2 = 0 ;
54002 PyObject * obj0 = 0 ;
54003 PyObject * obj1 = 0 ;
54004 char * kwnames[] = {
54005 (char *) "self",(char *) "col", NULL
54006 };
54007
54008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54010 if (!SWIG_IsOK(res1)) {
54011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54012 }
54013 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54014 ecode2 = SWIG_AsVal_int(obj1, &val2);
54015 if (!SWIG_IsOK(ecode2)) {
54016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54017 }
54018 arg2 = static_cast< int >(val2);
54019 {
54020 PyThreadState* __tstate = wxPyBeginAllowThreads();
54021 (arg1)->SetCol(arg2);
54022 wxPyEndAllowThreads(__tstate);
54023 if (PyErr_Occurred()) SWIG_fail;
54024 }
54025 resultobj = SWIG_Py_Void();
54026 return resultobj;
54027 fail:
54028 return NULL;
54029 }
54030
54031
54032 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54033 PyObject *resultobj = 0;
54034 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54035 PyObject *arg2 = (PyObject *) 0 ;
54036 bool result;
54037 void *argp1 = 0 ;
54038 int res1 = 0 ;
54039 PyObject * obj0 = 0 ;
54040 PyObject * obj1 = 0 ;
54041 char * kwnames[] = {
54042 (char *) "self",(char *) "other", NULL
54043 };
54044
54045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54047 if (!SWIG_IsOK(res1)) {
54048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54049 }
54050 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54051 arg2 = obj1;
54052 {
54053 result = (bool)wxGBPosition___eq__(arg1,arg2);
54054 if (PyErr_Occurred()) SWIG_fail;
54055 }
54056 {
54057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54058 }
54059 return resultobj;
54060 fail:
54061 return NULL;
54062 }
54063
54064
54065 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54066 PyObject *resultobj = 0;
54067 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54068 PyObject *arg2 = (PyObject *) 0 ;
54069 bool result;
54070 void *argp1 = 0 ;
54071 int res1 = 0 ;
54072 PyObject * obj0 = 0 ;
54073 PyObject * obj1 = 0 ;
54074 char * kwnames[] = {
54075 (char *) "self",(char *) "other", NULL
54076 };
54077
54078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54080 if (!SWIG_IsOK(res1)) {
54081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54082 }
54083 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54084 arg2 = obj1;
54085 {
54086 result = (bool)wxGBPosition___ne__(arg1,arg2);
54087 if (PyErr_Occurred()) SWIG_fail;
54088 }
54089 {
54090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54091 }
54092 return resultobj;
54093 fail:
54094 return NULL;
54095 }
54096
54097
54098 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54099 PyObject *resultobj = 0;
54100 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54101 int arg2 = (int) 0 ;
54102 int arg3 = (int) 0 ;
54103 void *argp1 = 0 ;
54104 int res1 = 0 ;
54105 int val2 ;
54106 int ecode2 = 0 ;
54107 int val3 ;
54108 int ecode3 = 0 ;
54109 PyObject * obj0 = 0 ;
54110 PyObject * obj1 = 0 ;
54111 PyObject * obj2 = 0 ;
54112 char * kwnames[] = {
54113 (char *) "self",(char *) "row",(char *) "col", NULL
54114 };
54115
54116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54118 if (!SWIG_IsOK(res1)) {
54119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54120 }
54121 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54122 if (obj1) {
54123 ecode2 = SWIG_AsVal_int(obj1, &val2);
54124 if (!SWIG_IsOK(ecode2)) {
54125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54126 }
54127 arg2 = static_cast< int >(val2);
54128 }
54129 if (obj2) {
54130 ecode3 = SWIG_AsVal_int(obj2, &val3);
54131 if (!SWIG_IsOK(ecode3)) {
54132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54133 }
54134 arg3 = static_cast< int >(val3);
54135 }
54136 {
54137 PyThreadState* __tstate = wxPyBeginAllowThreads();
54138 wxGBPosition_Set(arg1,arg2,arg3);
54139 wxPyEndAllowThreads(__tstate);
54140 if (PyErr_Occurred()) SWIG_fail;
54141 }
54142 resultobj = SWIG_Py_Void();
54143 return resultobj;
54144 fail:
54145 return NULL;
54146 }
54147
54148
54149 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54150 PyObject *resultobj = 0;
54151 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54152 PyObject *result = 0 ;
54153 void *argp1 = 0 ;
54154 int res1 = 0 ;
54155 PyObject *swig_obj[1] ;
54156
54157 if (!args) SWIG_fail;
54158 swig_obj[0] = args;
54159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54160 if (!SWIG_IsOK(res1)) {
54161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54162 }
54163 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54164 {
54165 PyThreadState* __tstate = wxPyBeginAllowThreads();
54166 result = (PyObject *)wxGBPosition_Get(arg1);
54167 wxPyEndAllowThreads(__tstate);
54168 if (PyErr_Occurred()) SWIG_fail;
54169 }
54170 resultobj = result;
54171 return resultobj;
54172 fail:
54173 return NULL;
54174 }
54175
54176
54177 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54178 PyObject *obj;
54179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54180 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54181 return SWIG_Py_Void();
54182 }
54183
54184 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54185 return SWIG_Python_InitShadowInstance(args);
54186 }
54187
54188 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54189 PyObject *resultobj = 0;
54190 int arg1 = (int) 1 ;
54191 int arg2 = (int) 1 ;
54192 wxGBSpan *result = 0 ;
54193 int val1 ;
54194 int ecode1 = 0 ;
54195 int val2 ;
54196 int ecode2 = 0 ;
54197 PyObject * obj0 = 0 ;
54198 PyObject * obj1 = 0 ;
54199 char * kwnames[] = {
54200 (char *) "rowspan",(char *) "colspan", NULL
54201 };
54202
54203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54204 if (obj0) {
54205 ecode1 = SWIG_AsVal_int(obj0, &val1);
54206 if (!SWIG_IsOK(ecode1)) {
54207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54208 }
54209 arg1 = static_cast< int >(val1);
54210 }
54211 if (obj1) {
54212 ecode2 = SWIG_AsVal_int(obj1, &val2);
54213 if (!SWIG_IsOK(ecode2)) {
54214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54215 }
54216 arg2 = static_cast< int >(val2);
54217 }
54218 {
54219 PyThreadState* __tstate = wxPyBeginAllowThreads();
54220 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54221 wxPyEndAllowThreads(__tstate);
54222 if (PyErr_Occurred()) SWIG_fail;
54223 }
54224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54225 return resultobj;
54226 fail:
54227 return NULL;
54228 }
54229
54230
54231 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54232 PyObject *resultobj = 0;
54233 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54234 void *argp1 = 0 ;
54235 int res1 = 0 ;
54236 PyObject *swig_obj[1] ;
54237
54238 if (!args) SWIG_fail;
54239 swig_obj[0] = args;
54240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54241 if (!SWIG_IsOK(res1)) {
54242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54243 }
54244 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54245 {
54246 PyThreadState* __tstate = wxPyBeginAllowThreads();
54247 delete arg1;
54248
54249 wxPyEndAllowThreads(__tstate);
54250 if (PyErr_Occurred()) SWIG_fail;
54251 }
54252 resultobj = SWIG_Py_Void();
54253 return resultobj;
54254 fail:
54255 return NULL;
54256 }
54257
54258
54259 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54260 PyObject *resultobj = 0;
54261 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54262 int result;
54263 void *argp1 = 0 ;
54264 int res1 = 0 ;
54265 PyObject *swig_obj[1] ;
54266
54267 if (!args) SWIG_fail;
54268 swig_obj[0] = args;
54269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54270 if (!SWIG_IsOK(res1)) {
54271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54272 }
54273 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54274 {
54275 PyThreadState* __tstate = wxPyBeginAllowThreads();
54276 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54277 wxPyEndAllowThreads(__tstate);
54278 if (PyErr_Occurred()) SWIG_fail;
54279 }
54280 resultobj = SWIG_From_int(static_cast< int >(result));
54281 return resultobj;
54282 fail:
54283 return NULL;
54284 }
54285
54286
54287 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54288 PyObject *resultobj = 0;
54289 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54290 int result;
54291 void *argp1 = 0 ;
54292 int res1 = 0 ;
54293 PyObject *swig_obj[1] ;
54294
54295 if (!args) SWIG_fail;
54296 swig_obj[0] = args;
54297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54298 if (!SWIG_IsOK(res1)) {
54299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54300 }
54301 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54302 {
54303 PyThreadState* __tstate = wxPyBeginAllowThreads();
54304 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54305 wxPyEndAllowThreads(__tstate);
54306 if (PyErr_Occurred()) SWIG_fail;
54307 }
54308 resultobj = SWIG_From_int(static_cast< int >(result));
54309 return resultobj;
54310 fail:
54311 return NULL;
54312 }
54313
54314
54315 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54316 PyObject *resultobj = 0;
54317 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54318 int arg2 ;
54319 void *argp1 = 0 ;
54320 int res1 = 0 ;
54321 int val2 ;
54322 int ecode2 = 0 ;
54323 PyObject * obj0 = 0 ;
54324 PyObject * obj1 = 0 ;
54325 char * kwnames[] = {
54326 (char *) "self",(char *) "rowspan", NULL
54327 };
54328
54329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54331 if (!SWIG_IsOK(res1)) {
54332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54333 }
54334 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54335 ecode2 = SWIG_AsVal_int(obj1, &val2);
54336 if (!SWIG_IsOK(ecode2)) {
54337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54338 }
54339 arg2 = static_cast< int >(val2);
54340 {
54341 PyThreadState* __tstate = wxPyBeginAllowThreads();
54342 (arg1)->SetRowspan(arg2);
54343 wxPyEndAllowThreads(__tstate);
54344 if (PyErr_Occurred()) SWIG_fail;
54345 }
54346 resultobj = SWIG_Py_Void();
54347 return resultobj;
54348 fail:
54349 return NULL;
54350 }
54351
54352
54353 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54354 PyObject *resultobj = 0;
54355 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54356 int arg2 ;
54357 void *argp1 = 0 ;
54358 int res1 = 0 ;
54359 int val2 ;
54360 int ecode2 = 0 ;
54361 PyObject * obj0 = 0 ;
54362 PyObject * obj1 = 0 ;
54363 char * kwnames[] = {
54364 (char *) "self",(char *) "colspan", NULL
54365 };
54366
54367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
54368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54369 if (!SWIG_IsOK(res1)) {
54370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54371 }
54372 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54373 ecode2 = SWIG_AsVal_int(obj1, &val2);
54374 if (!SWIG_IsOK(ecode2)) {
54375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
54376 }
54377 arg2 = static_cast< int >(val2);
54378 {
54379 PyThreadState* __tstate = wxPyBeginAllowThreads();
54380 (arg1)->SetColspan(arg2);
54381 wxPyEndAllowThreads(__tstate);
54382 if (PyErr_Occurred()) SWIG_fail;
54383 }
54384 resultobj = SWIG_Py_Void();
54385 return resultobj;
54386 fail:
54387 return NULL;
54388 }
54389
54390
54391 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54392 PyObject *resultobj = 0;
54393 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54394 PyObject *arg2 = (PyObject *) 0 ;
54395 bool result;
54396 void *argp1 = 0 ;
54397 int res1 = 0 ;
54398 PyObject * obj0 = 0 ;
54399 PyObject * obj1 = 0 ;
54400 char * kwnames[] = {
54401 (char *) "self",(char *) "other", NULL
54402 };
54403
54404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54406 if (!SWIG_IsOK(res1)) {
54407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54408 }
54409 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54410 arg2 = obj1;
54411 {
54412 result = (bool)wxGBSpan___eq__(arg1,arg2);
54413 if (PyErr_Occurred()) SWIG_fail;
54414 }
54415 {
54416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54417 }
54418 return resultobj;
54419 fail:
54420 return NULL;
54421 }
54422
54423
54424 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54425 PyObject *resultobj = 0;
54426 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54427 PyObject *arg2 = (PyObject *) 0 ;
54428 bool result;
54429 void *argp1 = 0 ;
54430 int res1 = 0 ;
54431 PyObject * obj0 = 0 ;
54432 PyObject * obj1 = 0 ;
54433 char * kwnames[] = {
54434 (char *) "self",(char *) "other", NULL
54435 };
54436
54437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54439 if (!SWIG_IsOK(res1)) {
54440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54441 }
54442 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54443 arg2 = obj1;
54444 {
54445 result = (bool)wxGBSpan___ne__(arg1,arg2);
54446 if (PyErr_Occurred()) SWIG_fail;
54447 }
54448 {
54449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54450 }
54451 return resultobj;
54452 fail:
54453 return NULL;
54454 }
54455
54456
54457 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54458 PyObject *resultobj = 0;
54459 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54460 int arg2 = (int) 1 ;
54461 int arg3 = (int) 1 ;
54462 void *argp1 = 0 ;
54463 int res1 = 0 ;
54464 int val2 ;
54465 int ecode2 = 0 ;
54466 int val3 ;
54467 int ecode3 = 0 ;
54468 PyObject * obj0 = 0 ;
54469 PyObject * obj1 = 0 ;
54470 PyObject * obj2 = 0 ;
54471 char * kwnames[] = {
54472 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
54473 };
54474
54475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54477 if (!SWIG_IsOK(res1)) {
54478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54479 }
54480 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54481 if (obj1) {
54482 ecode2 = SWIG_AsVal_int(obj1, &val2);
54483 if (!SWIG_IsOK(ecode2)) {
54484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
54485 }
54486 arg2 = static_cast< int >(val2);
54487 }
54488 if (obj2) {
54489 ecode3 = SWIG_AsVal_int(obj2, &val3);
54490 if (!SWIG_IsOK(ecode3)) {
54491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
54492 }
54493 arg3 = static_cast< int >(val3);
54494 }
54495 {
54496 PyThreadState* __tstate = wxPyBeginAllowThreads();
54497 wxGBSpan_Set(arg1,arg2,arg3);
54498 wxPyEndAllowThreads(__tstate);
54499 if (PyErr_Occurred()) SWIG_fail;
54500 }
54501 resultobj = SWIG_Py_Void();
54502 return resultobj;
54503 fail:
54504 return NULL;
54505 }
54506
54507
54508 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54509 PyObject *resultobj = 0;
54510 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54511 PyObject *result = 0 ;
54512 void *argp1 = 0 ;
54513 int res1 = 0 ;
54514 PyObject *swig_obj[1] ;
54515
54516 if (!args) SWIG_fail;
54517 swig_obj[0] = args;
54518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54519 if (!SWIG_IsOK(res1)) {
54520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54521 }
54522 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54523 {
54524 PyThreadState* __tstate = wxPyBeginAllowThreads();
54525 result = (PyObject *)wxGBSpan_Get(arg1);
54526 wxPyEndAllowThreads(__tstate);
54527 if (PyErr_Occurred()) SWIG_fail;
54528 }
54529 resultobj = result;
54530 return resultobj;
54531 fail:
54532 return NULL;
54533 }
54534
54535
54536 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54537 PyObject *obj;
54538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54539 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
54540 return SWIG_Py_Void();
54541 }
54542
54543 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54544 return SWIG_Python_InitShadowInstance(args);
54545 }
54546
54547 SWIGINTERN int DefaultSpan_set(PyObject *) {
54548 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
54549 return 1;
54550 }
54551
54552
54553 SWIGINTERN PyObject *DefaultSpan_get(void) {
54554 PyObject *pyobj = 0;
54555
54556 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
54557 return pyobj;
54558 }
54559
54560
54561 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54562 PyObject *resultobj = 0;
54563 wxGBSizerItem *result = 0 ;
54564
54565 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
54566 {
54567 PyThreadState* __tstate = wxPyBeginAllowThreads();
54568 result = (wxGBSizerItem *)new wxGBSizerItem();
54569 wxPyEndAllowThreads(__tstate);
54570 if (PyErr_Occurred()) SWIG_fail;
54571 }
54572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
54573 return resultobj;
54574 fail:
54575 return NULL;
54576 }
54577
54578
54579 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54580 PyObject *resultobj = 0;
54581 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54582 void *argp1 = 0 ;
54583 int res1 = 0 ;
54584 PyObject *swig_obj[1] ;
54585
54586 if (!args) SWIG_fail;
54587 swig_obj[0] = args;
54588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54589 if (!SWIG_IsOK(res1)) {
54590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54591 }
54592 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54593 {
54594 PyThreadState* __tstate = wxPyBeginAllowThreads();
54595 delete arg1;
54596
54597 wxPyEndAllowThreads(__tstate);
54598 if (PyErr_Occurred()) SWIG_fail;
54599 }
54600 resultobj = SWIG_Py_Void();
54601 return resultobj;
54602 fail:
54603 return NULL;
54604 }
54605
54606
54607 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54608 PyObject *resultobj = 0;
54609 wxWindow *arg1 = (wxWindow *) 0 ;
54610 wxGBPosition *arg2 = 0 ;
54611 wxGBSpan *arg3 = 0 ;
54612 int arg4 ;
54613 int arg5 ;
54614 PyObject *arg6 = (PyObject *) NULL ;
54615 wxGBSizerItem *result = 0 ;
54616 void *argp1 = 0 ;
54617 int res1 = 0 ;
54618 wxGBPosition temp2 ;
54619 wxGBSpan temp3 ;
54620 int val4 ;
54621 int ecode4 = 0 ;
54622 int val5 ;
54623 int ecode5 = 0 ;
54624 PyObject * obj0 = 0 ;
54625 PyObject * obj1 = 0 ;
54626 PyObject * obj2 = 0 ;
54627 PyObject * obj3 = 0 ;
54628 PyObject * obj4 = 0 ;
54629 PyObject * obj5 = 0 ;
54630 char * kwnames[] = {
54631 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54632 };
54633
54634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
54636 if (!SWIG_IsOK(res1)) {
54637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
54638 }
54639 arg1 = reinterpret_cast< wxWindow * >(argp1);
54640 {
54641 arg2 = &temp2;
54642 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54643 }
54644 {
54645 arg3 = &temp3;
54646 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54647 }
54648 ecode4 = SWIG_AsVal_int(obj3, &val4);
54649 if (!SWIG_IsOK(ecode4)) {
54650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
54651 }
54652 arg4 = static_cast< int >(val4);
54653 ecode5 = SWIG_AsVal_int(obj4, &val5);
54654 if (!SWIG_IsOK(ecode5)) {
54655 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
54656 }
54657 arg5 = static_cast< int >(val5);
54658 if (obj5) {
54659 arg6 = obj5;
54660 }
54661 {
54662 PyThreadState* __tstate = wxPyBeginAllowThreads();
54663 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54664 wxPyEndAllowThreads(__tstate);
54665 if (PyErr_Occurred()) SWIG_fail;
54666 }
54667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54668 return resultobj;
54669 fail:
54670 return NULL;
54671 }
54672
54673
54674 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54675 PyObject *resultobj = 0;
54676 wxSizer *arg1 = (wxSizer *) 0 ;
54677 wxGBPosition *arg2 = 0 ;
54678 wxGBSpan *arg3 = 0 ;
54679 int arg4 ;
54680 int arg5 ;
54681 PyObject *arg6 = (PyObject *) NULL ;
54682 wxGBSizerItem *result = 0 ;
54683 int res1 = 0 ;
54684 wxGBPosition temp2 ;
54685 wxGBSpan temp3 ;
54686 int val4 ;
54687 int ecode4 = 0 ;
54688 int val5 ;
54689 int ecode5 = 0 ;
54690 PyObject * obj0 = 0 ;
54691 PyObject * obj1 = 0 ;
54692 PyObject * obj2 = 0 ;
54693 PyObject * obj3 = 0 ;
54694 PyObject * obj4 = 0 ;
54695 PyObject * obj5 = 0 ;
54696 char * kwnames[] = {
54697 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54698 };
54699
54700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54701 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
54702 if (!SWIG_IsOK(res1)) {
54703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
54704 }
54705 {
54706 arg2 = &temp2;
54707 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54708 }
54709 {
54710 arg3 = &temp3;
54711 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54712 }
54713 ecode4 = SWIG_AsVal_int(obj3, &val4);
54714 if (!SWIG_IsOK(ecode4)) {
54715 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
54716 }
54717 arg4 = static_cast< int >(val4);
54718 ecode5 = SWIG_AsVal_int(obj4, &val5);
54719 if (!SWIG_IsOK(ecode5)) {
54720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
54721 }
54722 arg5 = static_cast< int >(val5);
54723 if (obj5) {
54724 arg6 = obj5;
54725 }
54726 {
54727 PyThreadState* __tstate = wxPyBeginAllowThreads();
54728 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54729 wxPyEndAllowThreads(__tstate);
54730 if (PyErr_Occurred()) SWIG_fail;
54731 }
54732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54733 return resultobj;
54734 fail:
54735 return NULL;
54736 }
54737
54738
54739 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54740 PyObject *resultobj = 0;
54741 int arg1 ;
54742 int arg2 ;
54743 wxGBPosition *arg3 = 0 ;
54744 wxGBSpan *arg4 = 0 ;
54745 int arg5 ;
54746 int arg6 ;
54747 PyObject *arg7 = (PyObject *) NULL ;
54748 wxGBSizerItem *result = 0 ;
54749 int val1 ;
54750 int ecode1 = 0 ;
54751 int val2 ;
54752 int ecode2 = 0 ;
54753 wxGBPosition temp3 ;
54754 wxGBSpan temp4 ;
54755 int val5 ;
54756 int ecode5 = 0 ;
54757 int val6 ;
54758 int ecode6 = 0 ;
54759 PyObject * obj0 = 0 ;
54760 PyObject * obj1 = 0 ;
54761 PyObject * obj2 = 0 ;
54762 PyObject * obj3 = 0 ;
54763 PyObject * obj4 = 0 ;
54764 PyObject * obj5 = 0 ;
54765 PyObject * obj6 = 0 ;
54766 char * kwnames[] = {
54767 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54768 };
54769
54770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54771 ecode1 = SWIG_AsVal_int(obj0, &val1);
54772 if (!SWIG_IsOK(ecode1)) {
54773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
54774 }
54775 arg1 = static_cast< int >(val1);
54776 ecode2 = SWIG_AsVal_int(obj1, &val2);
54777 if (!SWIG_IsOK(ecode2)) {
54778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
54779 }
54780 arg2 = static_cast< int >(val2);
54781 {
54782 arg3 = &temp3;
54783 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54784 }
54785 {
54786 arg4 = &temp4;
54787 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54788 }
54789 ecode5 = SWIG_AsVal_int(obj4, &val5);
54790 if (!SWIG_IsOK(ecode5)) {
54791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
54792 }
54793 arg5 = static_cast< int >(val5);
54794 ecode6 = SWIG_AsVal_int(obj5, &val6);
54795 if (!SWIG_IsOK(ecode6)) {
54796 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
54797 }
54798 arg6 = static_cast< int >(val6);
54799 if (obj6) {
54800 arg7 = obj6;
54801 }
54802 {
54803 PyThreadState* __tstate = wxPyBeginAllowThreads();
54804 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54805 wxPyEndAllowThreads(__tstate);
54806 if (PyErr_Occurred()) SWIG_fail;
54807 }
54808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54809 return resultobj;
54810 fail:
54811 return NULL;
54812 }
54813
54814
54815 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54816 PyObject *resultobj = 0;
54817 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54818 wxGBPosition result;
54819 void *argp1 = 0 ;
54820 int res1 = 0 ;
54821 PyObject *swig_obj[1] ;
54822
54823 if (!args) SWIG_fail;
54824 swig_obj[0] = args;
54825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54826 if (!SWIG_IsOK(res1)) {
54827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54828 }
54829 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54830 {
54831 PyThreadState* __tstate = wxPyBeginAllowThreads();
54832 result = ((wxGBSizerItem const *)arg1)->GetPos();
54833 wxPyEndAllowThreads(__tstate);
54834 if (PyErr_Occurred()) SWIG_fail;
54835 }
54836 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54837 return resultobj;
54838 fail:
54839 return NULL;
54840 }
54841
54842
54843 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54844 PyObject *resultobj = 0;
54845 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54846 wxGBSpan result;
54847 void *argp1 = 0 ;
54848 int res1 = 0 ;
54849 PyObject *swig_obj[1] ;
54850
54851 if (!args) SWIG_fail;
54852 swig_obj[0] = args;
54853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54854 if (!SWIG_IsOK(res1)) {
54855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54856 }
54857 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54858 {
54859 PyThreadState* __tstate = wxPyBeginAllowThreads();
54860 result = ((wxGBSizerItem const *)arg1)->GetSpan();
54861 wxPyEndAllowThreads(__tstate);
54862 if (PyErr_Occurred()) SWIG_fail;
54863 }
54864 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54865 return resultobj;
54866 fail:
54867 return NULL;
54868 }
54869
54870
54871 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54872 PyObject *resultobj = 0;
54873 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54874 wxGBPosition *arg2 = 0 ;
54875 bool result;
54876 void *argp1 = 0 ;
54877 int res1 = 0 ;
54878 wxGBPosition temp2 ;
54879 PyObject * obj0 = 0 ;
54880 PyObject * obj1 = 0 ;
54881 char * kwnames[] = {
54882 (char *) "self",(char *) "pos", NULL
54883 };
54884
54885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
54886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54887 if (!SWIG_IsOK(res1)) {
54888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54889 }
54890 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54891 {
54892 arg2 = &temp2;
54893 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54894 }
54895 {
54896 PyThreadState* __tstate = wxPyBeginAllowThreads();
54897 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
54898 wxPyEndAllowThreads(__tstate);
54899 if (PyErr_Occurred()) SWIG_fail;
54900 }
54901 {
54902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54903 }
54904 return resultobj;
54905 fail:
54906 return NULL;
54907 }
54908
54909
54910 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54911 PyObject *resultobj = 0;
54912 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54913 wxGBSpan *arg2 = 0 ;
54914 bool result;
54915 void *argp1 = 0 ;
54916 int res1 = 0 ;
54917 wxGBSpan temp2 ;
54918 PyObject * obj0 = 0 ;
54919 PyObject * obj1 = 0 ;
54920 char * kwnames[] = {
54921 (char *) "self",(char *) "span", NULL
54922 };
54923
54924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54926 if (!SWIG_IsOK(res1)) {
54927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54928 }
54929 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54930 {
54931 arg2 = &temp2;
54932 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
54933 }
54934 {
54935 PyThreadState* __tstate = wxPyBeginAllowThreads();
54936 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
54937 wxPyEndAllowThreads(__tstate);
54938 if (PyErr_Occurred()) SWIG_fail;
54939 }
54940 {
54941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54942 }
54943 return resultobj;
54944 fail:
54945 return NULL;
54946 }
54947
54948
54949 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54950 PyObject *resultobj = 0;
54951 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54952 wxGBSizerItem *arg2 = 0 ;
54953 bool result;
54954 void *argp1 = 0 ;
54955 int res1 = 0 ;
54956 void *argp2 = 0 ;
54957 int res2 = 0 ;
54958 PyObject * obj0 = 0 ;
54959 PyObject * obj1 = 0 ;
54960 char * kwnames[] = {
54961 (char *) "self",(char *) "other", NULL
54962 };
54963
54964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
54965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54966 if (!SWIG_IsOK(res1)) {
54967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54968 }
54969 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
54971 if (!SWIG_IsOK(res2)) {
54972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
54973 }
54974 if (!argp2) {
54975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
54976 }
54977 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54978 {
54979 PyThreadState* __tstate = wxPyBeginAllowThreads();
54980 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
54981 wxPyEndAllowThreads(__tstate);
54982 if (PyErr_Occurred()) SWIG_fail;
54983 }
54984 {
54985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54986 }
54987 return resultobj;
54988 fail:
54989 return NULL;
54990 }
54991
54992
54993 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54994 PyObject *resultobj = 0;
54995 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54996 wxGBPosition *arg2 = 0 ;
54997 wxGBSpan *arg3 = 0 ;
54998 bool result;
54999 void *argp1 = 0 ;
55000 int res1 = 0 ;
55001 wxGBPosition temp2 ;
55002 wxGBSpan temp3 ;
55003 PyObject * obj0 = 0 ;
55004 PyObject * obj1 = 0 ;
55005 PyObject * obj2 = 0 ;
55006 char * kwnames[] = {
55007 (char *) "self",(char *) "pos",(char *) "span", NULL
55008 };
55009
55010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55012 if (!SWIG_IsOK(res1)) {
55013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55014 }
55015 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55016 {
55017 arg2 = &temp2;
55018 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55019 }
55020 {
55021 arg3 = &temp3;
55022 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55023 }
55024 {
55025 PyThreadState* __tstate = wxPyBeginAllowThreads();
55026 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55027 wxPyEndAllowThreads(__tstate);
55028 if (PyErr_Occurred()) SWIG_fail;
55029 }
55030 {
55031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55032 }
55033 return resultobj;
55034 fail:
55035 return NULL;
55036 }
55037
55038
55039 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55040 PyObject *resultobj = 0;
55041 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55042 wxGBPosition result;
55043 void *argp1 = 0 ;
55044 int res1 = 0 ;
55045 PyObject *swig_obj[1] ;
55046
55047 if (!args) SWIG_fail;
55048 swig_obj[0] = args;
55049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55050 if (!SWIG_IsOK(res1)) {
55051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55052 }
55053 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55054 {
55055 PyThreadState* __tstate = wxPyBeginAllowThreads();
55056 result = wxGBSizerItem_GetEndPos(arg1);
55057 wxPyEndAllowThreads(__tstate);
55058 if (PyErr_Occurred()) SWIG_fail;
55059 }
55060 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55061 return resultobj;
55062 fail:
55063 return NULL;
55064 }
55065
55066
55067 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55068 PyObject *resultobj = 0;
55069 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55070 wxGridBagSizer *result = 0 ;
55071 void *argp1 = 0 ;
55072 int res1 = 0 ;
55073 PyObject *swig_obj[1] ;
55074
55075 if (!args) SWIG_fail;
55076 swig_obj[0] = args;
55077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55078 if (!SWIG_IsOK(res1)) {
55079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55080 }
55081 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55082 {
55083 PyThreadState* __tstate = wxPyBeginAllowThreads();
55084 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55085 wxPyEndAllowThreads(__tstate);
55086 if (PyErr_Occurred()) SWIG_fail;
55087 }
55088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55089 return resultobj;
55090 fail:
55091 return NULL;
55092 }
55093
55094
55095 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55096 PyObject *resultobj = 0;
55097 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55098 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55099 void *argp1 = 0 ;
55100 int res1 = 0 ;
55101 void *argp2 = 0 ;
55102 int res2 = 0 ;
55103 PyObject * obj0 = 0 ;
55104 PyObject * obj1 = 0 ;
55105 char * kwnames[] = {
55106 (char *) "self",(char *) "sizer", NULL
55107 };
55108
55109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55111 if (!SWIG_IsOK(res1)) {
55112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55113 }
55114 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55115 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55116 if (!SWIG_IsOK(res2)) {
55117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55118 }
55119 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55120 {
55121 PyThreadState* __tstate = wxPyBeginAllowThreads();
55122 (arg1)->SetGBSizer(arg2);
55123 wxPyEndAllowThreads(__tstate);
55124 if (PyErr_Occurred()) SWIG_fail;
55125 }
55126 resultobj = SWIG_Py_Void();
55127 return resultobj;
55128 fail:
55129 return NULL;
55130 }
55131
55132
55133 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55134 PyObject *obj;
55135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55136 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55137 return SWIG_Py_Void();
55138 }
55139
55140 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55141 return SWIG_Python_InitShadowInstance(args);
55142 }
55143
55144 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55145 PyObject *resultobj = 0;
55146 int arg1 = (int) 0 ;
55147 int arg2 = (int) 0 ;
55148 wxGridBagSizer *result = 0 ;
55149 int val1 ;
55150 int ecode1 = 0 ;
55151 int val2 ;
55152 int ecode2 = 0 ;
55153 PyObject * obj0 = 0 ;
55154 PyObject * obj1 = 0 ;
55155 char * kwnames[] = {
55156 (char *) "vgap",(char *) "hgap", NULL
55157 };
55158
55159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55160 if (obj0) {
55161 ecode1 = SWIG_AsVal_int(obj0, &val1);
55162 if (!SWIG_IsOK(ecode1)) {
55163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55164 }
55165 arg1 = static_cast< int >(val1);
55166 }
55167 if (obj1) {
55168 ecode2 = SWIG_AsVal_int(obj1, &val2);
55169 if (!SWIG_IsOK(ecode2)) {
55170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55171 }
55172 arg2 = static_cast< int >(val2);
55173 }
55174 {
55175 PyThreadState* __tstate = wxPyBeginAllowThreads();
55176 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55177 wxPyEndAllowThreads(__tstate);
55178 if (PyErr_Occurred()) SWIG_fail;
55179 }
55180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55181 return resultobj;
55182 fail:
55183 return NULL;
55184 }
55185
55186
55187 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55188 PyObject *resultobj = 0;
55189 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55190 PyObject *arg2 = (PyObject *) 0 ;
55191 wxGBPosition *arg3 = 0 ;
55192 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55193 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55194 int arg5 = (int) 0 ;
55195 int arg6 = (int) 0 ;
55196 PyObject *arg7 = (PyObject *) NULL ;
55197 wxGBSizerItem *result = 0 ;
55198 void *argp1 = 0 ;
55199 int res1 = 0 ;
55200 wxGBPosition temp3 ;
55201 wxGBSpan temp4 ;
55202 int val5 ;
55203 int ecode5 = 0 ;
55204 int val6 ;
55205 int ecode6 = 0 ;
55206 PyObject * obj0 = 0 ;
55207 PyObject * obj1 = 0 ;
55208 PyObject * obj2 = 0 ;
55209 PyObject * obj3 = 0 ;
55210 PyObject * obj4 = 0 ;
55211 PyObject * obj5 = 0 ;
55212 PyObject * obj6 = 0 ;
55213 char * kwnames[] = {
55214 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55215 };
55216
55217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55219 if (!SWIG_IsOK(res1)) {
55220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55221 }
55222 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55223 arg2 = obj1;
55224 {
55225 arg3 = &temp3;
55226 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55227 }
55228 if (obj3) {
55229 {
55230 arg4 = &temp4;
55231 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55232 }
55233 }
55234 if (obj4) {
55235 ecode5 = SWIG_AsVal_int(obj4, &val5);
55236 if (!SWIG_IsOK(ecode5)) {
55237 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55238 }
55239 arg5 = static_cast< int >(val5);
55240 }
55241 if (obj5) {
55242 ecode6 = SWIG_AsVal_int(obj5, &val6);
55243 if (!SWIG_IsOK(ecode6)) {
55244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55245 }
55246 arg6 = static_cast< int >(val6);
55247 }
55248 if (obj6) {
55249 arg7 = obj6;
55250 }
55251 {
55252 PyThreadState* __tstate = wxPyBeginAllowThreads();
55253 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55254 wxPyEndAllowThreads(__tstate);
55255 if (PyErr_Occurred()) SWIG_fail;
55256 }
55257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55258 return resultobj;
55259 fail:
55260 return NULL;
55261 }
55262
55263
55264 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55265 PyObject *resultobj = 0;
55266 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55267 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55268 wxGBSizerItem *result = 0 ;
55269 void *argp1 = 0 ;
55270 int res1 = 0 ;
55271 int res2 = 0 ;
55272 PyObject * obj0 = 0 ;
55273 PyObject * obj1 = 0 ;
55274 char * kwnames[] = {
55275 (char *) "self",(char *) "item", NULL
55276 };
55277
55278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55280 if (!SWIG_IsOK(res1)) {
55281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55282 }
55283 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55284 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55285 if (!SWIG_IsOK(res2)) {
55286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55287 }
55288 {
55289 PyThreadState* __tstate = wxPyBeginAllowThreads();
55290 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55291 wxPyEndAllowThreads(__tstate);
55292 if (PyErr_Occurred()) SWIG_fail;
55293 }
55294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55295 return resultobj;
55296 fail:
55297 return NULL;
55298 }
55299
55300
55301 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55302 PyObject *resultobj = 0;
55303 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55304 int arg2 ;
55305 int arg3 ;
55306 wxSize result;
55307 void *argp1 = 0 ;
55308 int res1 = 0 ;
55309 int val2 ;
55310 int ecode2 = 0 ;
55311 int val3 ;
55312 int ecode3 = 0 ;
55313 PyObject * obj0 = 0 ;
55314 PyObject * obj1 = 0 ;
55315 PyObject * obj2 = 0 ;
55316 char * kwnames[] = {
55317 (char *) "self",(char *) "row",(char *) "col", NULL
55318 };
55319
55320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55322 if (!SWIG_IsOK(res1)) {
55323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55324 }
55325 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55326 ecode2 = SWIG_AsVal_int(obj1, &val2);
55327 if (!SWIG_IsOK(ecode2)) {
55328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55329 }
55330 arg2 = static_cast< int >(val2);
55331 ecode3 = SWIG_AsVal_int(obj2, &val3);
55332 if (!SWIG_IsOK(ecode3)) {
55333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55334 }
55335 arg3 = static_cast< int >(val3);
55336 {
55337 PyThreadState* __tstate = wxPyBeginAllowThreads();
55338 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55339 wxPyEndAllowThreads(__tstate);
55340 if (PyErr_Occurred()) SWIG_fail;
55341 }
55342 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55343 return resultobj;
55344 fail:
55345 return NULL;
55346 }
55347
55348
55349 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55350 PyObject *resultobj = 0;
55351 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55352 wxSize result;
55353 void *argp1 = 0 ;
55354 int res1 = 0 ;
55355 PyObject *swig_obj[1] ;
55356
55357 if (!args) SWIG_fail;
55358 swig_obj[0] = args;
55359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55360 if (!SWIG_IsOK(res1)) {
55361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55362 }
55363 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55364 {
55365 PyThreadState* __tstate = wxPyBeginAllowThreads();
55366 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
55367 wxPyEndAllowThreads(__tstate);
55368 if (PyErr_Occurred()) SWIG_fail;
55369 }
55370 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55371 return resultobj;
55372 fail:
55373 return NULL;
55374 }
55375
55376
55377 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55378 PyObject *resultobj = 0;
55379 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55380 wxSize *arg2 = 0 ;
55381 void *argp1 = 0 ;
55382 int res1 = 0 ;
55383 wxSize temp2 ;
55384 PyObject * obj0 = 0 ;
55385 PyObject * obj1 = 0 ;
55386 char * kwnames[] = {
55387 (char *) "self",(char *) "sz", NULL
55388 };
55389
55390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
55391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55392 if (!SWIG_IsOK(res1)) {
55393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55394 }
55395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55396 {
55397 arg2 = &temp2;
55398 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
55399 }
55400 {
55401 PyThreadState* __tstate = wxPyBeginAllowThreads();
55402 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
55403 wxPyEndAllowThreads(__tstate);
55404 if (PyErr_Occurred()) SWIG_fail;
55405 }
55406 resultobj = SWIG_Py_Void();
55407 return resultobj;
55408 fail:
55409 return NULL;
55410 }
55411
55412
55413 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55414 PyObject *resultobj = 0;
55415 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55416 wxWindow *arg2 = (wxWindow *) 0 ;
55417 wxGBPosition result;
55418 void *argp1 = 0 ;
55419 int res1 = 0 ;
55420 void *argp2 = 0 ;
55421 int res2 = 0 ;
55422
55423 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55425 if (!SWIG_IsOK(res1)) {
55426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55427 }
55428 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55429 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55430 if (!SWIG_IsOK(res2)) {
55431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55432 }
55433 arg2 = reinterpret_cast< wxWindow * >(argp2);
55434 {
55435 PyThreadState* __tstate = wxPyBeginAllowThreads();
55436 result = (arg1)->GetItemPosition(arg2);
55437 wxPyEndAllowThreads(__tstate);
55438 if (PyErr_Occurred()) SWIG_fail;
55439 }
55440 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55441 return resultobj;
55442 fail:
55443 return NULL;
55444 }
55445
55446
55447 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55448 PyObject *resultobj = 0;
55449 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55450 wxSizer *arg2 = (wxSizer *) 0 ;
55451 wxGBPosition result;
55452 void *argp1 = 0 ;
55453 int res1 = 0 ;
55454 void *argp2 = 0 ;
55455 int res2 = 0 ;
55456
55457 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55459 if (!SWIG_IsOK(res1)) {
55460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55461 }
55462 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55463 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55464 if (!SWIG_IsOK(res2)) {
55465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55466 }
55467 arg2 = reinterpret_cast< wxSizer * >(argp2);
55468 {
55469 PyThreadState* __tstate = wxPyBeginAllowThreads();
55470 result = (arg1)->GetItemPosition(arg2);
55471 wxPyEndAllowThreads(__tstate);
55472 if (PyErr_Occurred()) SWIG_fail;
55473 }
55474 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55475 return resultobj;
55476 fail:
55477 return NULL;
55478 }
55479
55480
55481 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55482 PyObject *resultobj = 0;
55483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55484 size_t arg2 ;
55485 wxGBPosition result;
55486 void *argp1 = 0 ;
55487 int res1 = 0 ;
55488 size_t val2 ;
55489 int ecode2 = 0 ;
55490
55491 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55493 if (!SWIG_IsOK(res1)) {
55494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55495 }
55496 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55497 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55498 if (!SWIG_IsOK(ecode2)) {
55499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55500 }
55501 arg2 = static_cast< size_t >(val2);
55502 {
55503 PyThreadState* __tstate = wxPyBeginAllowThreads();
55504 result = (arg1)->GetItemPosition(arg2);
55505 wxPyEndAllowThreads(__tstate);
55506 if (PyErr_Occurred()) SWIG_fail;
55507 }
55508 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55509 return resultobj;
55510 fail:
55511 return NULL;
55512 }
55513
55514
55515 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
55516 int argc;
55517 PyObject *argv[3];
55518
55519 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
55520 --argc;
55521 if (argc == 2) {
55522 int _v = 0;
55523 {
55524 void *vptr = 0;
55525 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55526 _v = SWIG_CheckState(res);
55527 }
55528 if (!_v) goto check_1;
55529 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
55530 }
55531 check_1:
55532
55533 if (argc == 2) {
55534 int _v = 0;
55535 {
55536 void *vptr = 0;
55537 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55538 _v = SWIG_CheckState(res);
55539 }
55540 if (!_v) goto check_2;
55541 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
55542 }
55543 check_2:
55544
55545 if (argc == 2) {
55546 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
55547 }
55548
55549 fail:
55550 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
55551 return NULL;
55552 }
55553
55554
55555 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55556 PyObject *resultobj = 0;
55557 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55558 wxWindow *arg2 = (wxWindow *) 0 ;
55559 wxGBPosition *arg3 = 0 ;
55560 bool result;
55561 void *argp1 = 0 ;
55562 int res1 = 0 ;
55563 void *argp2 = 0 ;
55564 int res2 = 0 ;
55565 wxGBPosition temp3 ;
55566
55567 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55569 if (!SWIG_IsOK(res1)) {
55570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55571 }
55572 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55573 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55574 if (!SWIG_IsOK(res2)) {
55575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55576 }
55577 arg2 = reinterpret_cast< wxWindow * >(argp2);
55578 {
55579 arg3 = &temp3;
55580 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55581 }
55582 {
55583 PyThreadState* __tstate = wxPyBeginAllowThreads();
55584 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55585 wxPyEndAllowThreads(__tstate);
55586 if (PyErr_Occurred()) SWIG_fail;
55587 }
55588 {
55589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55590 }
55591 return resultobj;
55592 fail:
55593 return NULL;
55594 }
55595
55596
55597 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55598 PyObject *resultobj = 0;
55599 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55600 wxSizer *arg2 = (wxSizer *) 0 ;
55601 wxGBPosition *arg3 = 0 ;
55602 bool result;
55603 void *argp1 = 0 ;
55604 int res1 = 0 ;
55605 void *argp2 = 0 ;
55606 int res2 = 0 ;
55607 wxGBPosition temp3 ;
55608
55609 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55611 if (!SWIG_IsOK(res1)) {
55612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55613 }
55614 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55615 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55616 if (!SWIG_IsOK(res2)) {
55617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55618 }
55619 arg2 = reinterpret_cast< wxSizer * >(argp2);
55620 {
55621 arg3 = &temp3;
55622 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55623 }
55624 {
55625 PyThreadState* __tstate = wxPyBeginAllowThreads();
55626 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55627 wxPyEndAllowThreads(__tstate);
55628 if (PyErr_Occurred()) SWIG_fail;
55629 }
55630 {
55631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55632 }
55633 return resultobj;
55634 fail:
55635 return NULL;
55636 }
55637
55638
55639 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55640 PyObject *resultobj = 0;
55641 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55642 size_t arg2 ;
55643 wxGBPosition *arg3 = 0 ;
55644 bool result;
55645 void *argp1 = 0 ;
55646 int res1 = 0 ;
55647 size_t val2 ;
55648 int ecode2 = 0 ;
55649 wxGBPosition temp3 ;
55650
55651 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55653 if (!SWIG_IsOK(res1)) {
55654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55655 }
55656 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55657 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55658 if (!SWIG_IsOK(ecode2)) {
55659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55660 }
55661 arg2 = static_cast< size_t >(val2);
55662 {
55663 arg3 = &temp3;
55664 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55665 }
55666 {
55667 PyThreadState* __tstate = wxPyBeginAllowThreads();
55668 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55669 wxPyEndAllowThreads(__tstate);
55670 if (PyErr_Occurred()) SWIG_fail;
55671 }
55672 {
55673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55674 }
55675 return resultobj;
55676 fail:
55677 return NULL;
55678 }
55679
55680
55681 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
55682 int argc;
55683 PyObject *argv[4];
55684
55685 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
55686 --argc;
55687 if (argc == 3) {
55688 int _v = 0;
55689 {
55690 void *vptr = 0;
55691 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55692 _v = SWIG_CheckState(res);
55693 }
55694 if (!_v) goto check_1;
55695 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
55696 }
55697 check_1:
55698
55699 if (argc == 3) {
55700 int _v = 0;
55701 {
55702 void *vptr = 0;
55703 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55704 _v = SWIG_CheckState(res);
55705 }
55706 if (!_v) goto check_2;
55707 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
55708 }
55709 check_2:
55710
55711 if (argc == 3) {
55712 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
55713 }
55714
55715 fail:
55716 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
55717 return NULL;
55718 }
55719
55720
55721 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55722 PyObject *resultobj = 0;
55723 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55724 wxWindow *arg2 = (wxWindow *) 0 ;
55725 wxGBSpan result;
55726 void *argp1 = 0 ;
55727 int res1 = 0 ;
55728 void *argp2 = 0 ;
55729 int res2 = 0 ;
55730
55731 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55733 if (!SWIG_IsOK(res1)) {
55734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55735 }
55736 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55737 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55738 if (!SWIG_IsOK(res2)) {
55739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55740 }
55741 arg2 = reinterpret_cast< wxWindow * >(argp2);
55742 {
55743 PyThreadState* __tstate = wxPyBeginAllowThreads();
55744 result = (arg1)->GetItemSpan(arg2);
55745 wxPyEndAllowThreads(__tstate);
55746 if (PyErr_Occurred()) SWIG_fail;
55747 }
55748 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55749 return resultobj;
55750 fail:
55751 return NULL;
55752 }
55753
55754
55755 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55756 PyObject *resultobj = 0;
55757 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55758 wxSizer *arg2 = (wxSizer *) 0 ;
55759 wxGBSpan result;
55760 void *argp1 = 0 ;
55761 int res1 = 0 ;
55762 void *argp2 = 0 ;
55763 int res2 = 0 ;
55764
55765 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55767 if (!SWIG_IsOK(res1)) {
55768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55769 }
55770 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55771 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55772 if (!SWIG_IsOK(res2)) {
55773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55774 }
55775 arg2 = reinterpret_cast< wxSizer * >(argp2);
55776 {
55777 PyThreadState* __tstate = wxPyBeginAllowThreads();
55778 result = (arg1)->GetItemSpan(arg2);
55779 wxPyEndAllowThreads(__tstate);
55780 if (PyErr_Occurred()) SWIG_fail;
55781 }
55782 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55783 return resultobj;
55784 fail:
55785 return NULL;
55786 }
55787
55788
55789 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55790 PyObject *resultobj = 0;
55791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55792 size_t arg2 ;
55793 wxGBSpan result;
55794 void *argp1 = 0 ;
55795 int res1 = 0 ;
55796 size_t val2 ;
55797 int ecode2 = 0 ;
55798
55799 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55801 if (!SWIG_IsOK(res1)) {
55802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55803 }
55804 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55805 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55806 if (!SWIG_IsOK(ecode2)) {
55807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55808 }
55809 arg2 = static_cast< size_t >(val2);
55810 {
55811 PyThreadState* __tstate = wxPyBeginAllowThreads();
55812 result = (arg1)->GetItemSpan(arg2);
55813 wxPyEndAllowThreads(__tstate);
55814 if (PyErr_Occurred()) SWIG_fail;
55815 }
55816 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55817 return resultobj;
55818 fail:
55819 return NULL;
55820 }
55821
55822
55823 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
55824 int argc;
55825 PyObject *argv[3];
55826
55827 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
55828 --argc;
55829 if (argc == 2) {
55830 int _v = 0;
55831 {
55832 void *vptr = 0;
55833 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55834 _v = SWIG_CheckState(res);
55835 }
55836 if (!_v) goto check_1;
55837 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
55838 }
55839 check_1:
55840
55841 if (argc == 2) {
55842 int _v = 0;
55843 {
55844 void *vptr = 0;
55845 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55846 _v = SWIG_CheckState(res);
55847 }
55848 if (!_v) goto check_2;
55849 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
55850 }
55851 check_2:
55852
55853 if (argc == 2) {
55854 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
55855 }
55856
55857 fail:
55858 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
55859 return NULL;
55860 }
55861
55862
55863 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55864 PyObject *resultobj = 0;
55865 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55866 wxWindow *arg2 = (wxWindow *) 0 ;
55867 wxGBSpan *arg3 = 0 ;
55868 bool result;
55869 void *argp1 = 0 ;
55870 int res1 = 0 ;
55871 void *argp2 = 0 ;
55872 int res2 = 0 ;
55873 wxGBSpan temp3 ;
55874
55875 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55877 if (!SWIG_IsOK(res1)) {
55878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55879 }
55880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55881 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55882 if (!SWIG_IsOK(res2)) {
55883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55884 }
55885 arg2 = reinterpret_cast< wxWindow * >(argp2);
55886 {
55887 arg3 = &temp3;
55888 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
55889 }
55890 {
55891 PyThreadState* __tstate = wxPyBeginAllowThreads();
55892 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
55893 wxPyEndAllowThreads(__tstate);
55894 if (PyErr_Occurred()) SWIG_fail;
55895 }
55896 {
55897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55898 }
55899 return resultobj;
55900 fail:
55901 return NULL;
55902 }
55903
55904
55905 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55906 PyObject *resultobj = 0;
55907 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55908 wxSizer *arg2 = (wxSizer *) 0 ;
55909 wxGBSpan *arg3 = 0 ;
55910 bool result;
55911 void *argp1 = 0 ;
55912 int res1 = 0 ;
55913 void *argp2 = 0 ;
55914 int res2 = 0 ;
55915 wxGBSpan temp3 ;
55916
55917 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55919 if (!SWIG_IsOK(res1)) {
55920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55921 }
55922 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55923 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55924 if (!SWIG_IsOK(res2)) {
55925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55926 }
55927 arg2 = reinterpret_cast< wxSizer * >(argp2);
55928 {
55929 arg3 = &temp3;
55930 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
55931 }
55932 {
55933 PyThreadState* __tstate = wxPyBeginAllowThreads();
55934 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
55935 wxPyEndAllowThreads(__tstate);
55936 if (PyErr_Occurred()) SWIG_fail;
55937 }
55938 {
55939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55940 }
55941 return resultobj;
55942 fail:
55943 return NULL;
55944 }
55945
55946
55947 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55948 PyObject *resultobj = 0;
55949 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55950 size_t arg2 ;
55951 wxGBSpan *arg3 = 0 ;
55952 bool result;
55953 void *argp1 = 0 ;
55954 int res1 = 0 ;
55955 size_t val2 ;
55956 int ecode2 = 0 ;
55957 wxGBSpan temp3 ;
55958
55959 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55961 if (!SWIG_IsOK(res1)) {
55962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55963 }
55964 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55965 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55966 if (!SWIG_IsOK(ecode2)) {
55967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55968 }
55969 arg2 = static_cast< size_t >(val2);
55970 {
55971 arg3 = &temp3;
55972 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
55973 }
55974 {
55975 PyThreadState* __tstate = wxPyBeginAllowThreads();
55976 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
55977 wxPyEndAllowThreads(__tstate);
55978 if (PyErr_Occurred()) SWIG_fail;
55979 }
55980 {
55981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55982 }
55983 return resultobj;
55984 fail:
55985 return NULL;
55986 }
55987
55988
55989 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
55990 int argc;
55991 PyObject *argv[4];
55992
55993 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
55994 --argc;
55995 if (argc == 3) {
55996 int _v = 0;
55997 {
55998 void *vptr = 0;
55999 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56000 _v = SWIG_CheckState(res);
56001 }
56002 if (!_v) goto check_1;
56003 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56004 }
56005 check_1:
56006
56007 if (argc == 3) {
56008 int _v = 0;
56009 {
56010 void *vptr = 0;
56011 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56012 _v = SWIG_CheckState(res);
56013 }
56014 if (!_v) goto check_2;
56015 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56016 }
56017 check_2:
56018
56019 if (argc == 3) {
56020 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56021 }
56022
56023 fail:
56024 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56025 return NULL;
56026 }
56027
56028
56029 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56030 PyObject *resultobj = 0;
56031 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56032 wxWindow *arg2 = (wxWindow *) 0 ;
56033 wxGBSizerItem *result = 0 ;
56034 void *argp1 = 0 ;
56035 int res1 = 0 ;
56036 void *argp2 = 0 ;
56037 int res2 = 0 ;
56038
56039 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56041 if (!SWIG_IsOK(res1)) {
56042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56043 }
56044 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56045 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56046 if (!SWIG_IsOK(res2)) {
56047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56048 }
56049 arg2 = reinterpret_cast< wxWindow * >(argp2);
56050 {
56051 PyThreadState* __tstate = wxPyBeginAllowThreads();
56052 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56053 wxPyEndAllowThreads(__tstate);
56054 if (PyErr_Occurred()) SWIG_fail;
56055 }
56056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56057 return resultobj;
56058 fail:
56059 return NULL;
56060 }
56061
56062
56063 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56064 PyObject *resultobj = 0;
56065 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56066 wxSizer *arg2 = (wxSizer *) 0 ;
56067 wxGBSizerItem *result = 0 ;
56068 void *argp1 = 0 ;
56069 int res1 = 0 ;
56070 void *argp2 = 0 ;
56071 int res2 = 0 ;
56072
56073 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56075 if (!SWIG_IsOK(res1)) {
56076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56077 }
56078 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56079 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56080 if (!SWIG_IsOK(res2)) {
56081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56082 }
56083 arg2 = reinterpret_cast< wxSizer * >(argp2);
56084 {
56085 PyThreadState* __tstate = wxPyBeginAllowThreads();
56086 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56087 wxPyEndAllowThreads(__tstate);
56088 if (PyErr_Occurred()) SWIG_fail;
56089 }
56090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56091 return resultobj;
56092 fail:
56093 return NULL;
56094 }
56095
56096
56097 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56098 int argc;
56099 PyObject *argv[3];
56100
56101 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56102 --argc;
56103 if (argc == 2) {
56104 int _v = 0;
56105 {
56106 void *vptr = 0;
56107 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56108 _v = SWIG_CheckState(res);
56109 }
56110 if (!_v) goto check_1;
56111 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56112 }
56113 check_1:
56114
56115 if (argc == 2) {
56116 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56117 }
56118
56119 fail:
56120 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56121 return NULL;
56122 }
56123
56124
56125 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56126 PyObject *resultobj = 0;
56127 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56128 wxGBPosition *arg2 = 0 ;
56129 wxGBSizerItem *result = 0 ;
56130 void *argp1 = 0 ;
56131 int res1 = 0 ;
56132 wxGBPosition temp2 ;
56133 PyObject * obj0 = 0 ;
56134 PyObject * obj1 = 0 ;
56135 char * kwnames[] = {
56136 (char *) "self",(char *) "pos", NULL
56137 };
56138
56139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56141 if (!SWIG_IsOK(res1)) {
56142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56143 }
56144 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56145 {
56146 arg2 = &temp2;
56147 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56148 }
56149 {
56150 PyThreadState* __tstate = wxPyBeginAllowThreads();
56151 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56152 wxPyEndAllowThreads(__tstate);
56153 if (PyErr_Occurred()) SWIG_fail;
56154 }
56155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56156 return resultobj;
56157 fail:
56158 return NULL;
56159 }
56160
56161
56162 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56163 PyObject *resultobj = 0;
56164 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56165 wxPoint *arg2 = 0 ;
56166 wxGBSizerItem *result = 0 ;
56167 void *argp1 = 0 ;
56168 int res1 = 0 ;
56169 wxPoint temp2 ;
56170 PyObject * obj0 = 0 ;
56171 PyObject * obj1 = 0 ;
56172 char * kwnames[] = {
56173 (char *) "self",(char *) "pt", NULL
56174 };
56175
56176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56178 if (!SWIG_IsOK(res1)) {
56179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56180 }
56181 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56182 {
56183 arg2 = &temp2;
56184 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56185 }
56186 {
56187 PyThreadState* __tstate = wxPyBeginAllowThreads();
56188 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56189 wxPyEndAllowThreads(__tstate);
56190 if (PyErr_Occurred()) SWIG_fail;
56191 }
56192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56193 return resultobj;
56194 fail:
56195 return NULL;
56196 }
56197
56198
56199 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56200 PyObject *resultobj = 0;
56201 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56202 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56203 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56204 bool result;
56205 void *argp1 = 0 ;
56206 int res1 = 0 ;
56207 void *argp2 = 0 ;
56208 int res2 = 0 ;
56209 void *argp3 = 0 ;
56210 int res3 = 0 ;
56211 PyObject * obj0 = 0 ;
56212 PyObject * obj1 = 0 ;
56213 PyObject * obj2 = 0 ;
56214 char * kwnames[] = {
56215 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56216 };
56217
56218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56220 if (!SWIG_IsOK(res1)) {
56221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56222 }
56223 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56225 if (!SWIG_IsOK(res2)) {
56226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56227 }
56228 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56229 if (obj2) {
56230 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56231 if (!SWIG_IsOK(res3)) {
56232 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56233 }
56234 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56235 }
56236 {
56237 PyThreadState* __tstate = wxPyBeginAllowThreads();
56238 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56239 wxPyEndAllowThreads(__tstate);
56240 if (PyErr_Occurred()) SWIG_fail;
56241 }
56242 {
56243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56244 }
56245 return resultobj;
56246 fail:
56247 return NULL;
56248 }
56249
56250
56251 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56252 PyObject *resultobj = 0;
56253 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56254 wxGBPosition *arg2 = 0 ;
56255 wxGBSpan *arg3 = 0 ;
56256 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56257 bool result;
56258 void *argp1 = 0 ;
56259 int res1 = 0 ;
56260 wxGBPosition temp2 ;
56261 wxGBSpan temp3 ;
56262 void *argp4 = 0 ;
56263 int res4 = 0 ;
56264 PyObject * obj0 = 0 ;
56265 PyObject * obj1 = 0 ;
56266 PyObject * obj2 = 0 ;
56267 PyObject * obj3 = 0 ;
56268 char * kwnames[] = {
56269 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56270 };
56271
56272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56274 if (!SWIG_IsOK(res1)) {
56275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56276 }
56277 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56278 {
56279 arg2 = &temp2;
56280 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56281 }
56282 {
56283 arg3 = &temp3;
56284 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56285 }
56286 if (obj3) {
56287 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56288 if (!SWIG_IsOK(res4)) {
56289 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56290 }
56291 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56292 }
56293 {
56294 PyThreadState* __tstate = wxPyBeginAllowThreads();
56295 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56296 wxPyEndAllowThreads(__tstate);
56297 if (PyErr_Occurred()) SWIG_fail;
56298 }
56299 {
56300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56301 }
56302 return resultobj;
56303 fail:
56304 return NULL;
56305 }
56306
56307
56308 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56309 PyObject *obj;
56310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56311 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56312 return SWIG_Py_Void();
56313 }
56314
56315 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56316 return SWIG_Python_InitShadowInstance(args);
56317 }
56318
56319 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56320 PyObject *resultobj = 0;
56321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56322 wxRelationship arg2 ;
56323 wxWindow *arg3 = (wxWindow *) 0 ;
56324 wxEdge arg4 ;
56325 int arg5 = (int) 0 ;
56326 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56327 void *argp1 = 0 ;
56328 int res1 = 0 ;
56329 int val2 ;
56330 int ecode2 = 0 ;
56331 void *argp3 = 0 ;
56332 int res3 = 0 ;
56333 int val4 ;
56334 int ecode4 = 0 ;
56335 int val5 ;
56336 int ecode5 = 0 ;
56337 int val6 ;
56338 int ecode6 = 0 ;
56339 PyObject * obj0 = 0 ;
56340 PyObject * obj1 = 0 ;
56341 PyObject * obj2 = 0 ;
56342 PyObject * obj3 = 0 ;
56343 PyObject * obj4 = 0 ;
56344 PyObject * obj5 = 0 ;
56345 char * kwnames[] = {
56346 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
56347 };
56348
56349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
56350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56351 if (!SWIG_IsOK(res1)) {
56352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56353 }
56354 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56355 ecode2 = SWIG_AsVal_int(obj1, &val2);
56356 if (!SWIG_IsOK(ecode2)) {
56357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
56358 }
56359 arg2 = static_cast< wxRelationship >(val2);
56360 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56361 if (!SWIG_IsOK(res3)) {
56362 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
56363 }
56364 arg3 = reinterpret_cast< wxWindow * >(argp3);
56365 ecode4 = SWIG_AsVal_int(obj3, &val4);
56366 if (!SWIG_IsOK(ecode4)) {
56367 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
56368 }
56369 arg4 = static_cast< wxEdge >(val4);
56370 if (obj4) {
56371 ecode5 = SWIG_AsVal_int(obj4, &val5);
56372 if (!SWIG_IsOK(ecode5)) {
56373 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
56374 }
56375 arg5 = static_cast< int >(val5);
56376 }
56377 if (obj5) {
56378 ecode6 = SWIG_AsVal_int(obj5, &val6);
56379 if (!SWIG_IsOK(ecode6)) {
56380 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
56381 }
56382 arg6 = static_cast< int >(val6);
56383 }
56384 {
56385 PyThreadState* __tstate = wxPyBeginAllowThreads();
56386 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
56387 wxPyEndAllowThreads(__tstate);
56388 if (PyErr_Occurred()) SWIG_fail;
56389 }
56390 resultobj = SWIG_Py_Void();
56391 return resultobj;
56392 fail:
56393 return NULL;
56394 }
56395
56396
56397 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56398 PyObject *resultobj = 0;
56399 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56400 wxWindow *arg2 = (wxWindow *) 0 ;
56401 int arg3 = (int) 0 ;
56402 void *argp1 = 0 ;
56403 int res1 = 0 ;
56404 void *argp2 = 0 ;
56405 int res2 = 0 ;
56406 int val3 ;
56407 int ecode3 = 0 ;
56408 PyObject * obj0 = 0 ;
56409 PyObject * obj1 = 0 ;
56410 PyObject * obj2 = 0 ;
56411 char * kwnames[] = {
56412 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56413 };
56414
56415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56417 if (!SWIG_IsOK(res1)) {
56418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56419 }
56420 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56422 if (!SWIG_IsOK(res2)) {
56423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56424 }
56425 arg2 = reinterpret_cast< wxWindow * >(argp2);
56426 if (obj2) {
56427 ecode3 = SWIG_AsVal_int(obj2, &val3);
56428 if (!SWIG_IsOK(ecode3)) {
56429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
56430 }
56431 arg3 = static_cast< int >(val3);
56432 }
56433 {
56434 PyThreadState* __tstate = wxPyBeginAllowThreads();
56435 (arg1)->LeftOf(arg2,arg3);
56436 wxPyEndAllowThreads(__tstate);
56437 if (PyErr_Occurred()) SWIG_fail;
56438 }
56439 resultobj = SWIG_Py_Void();
56440 return resultobj;
56441 fail:
56442 return NULL;
56443 }
56444
56445
56446 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56447 PyObject *resultobj = 0;
56448 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56449 wxWindow *arg2 = (wxWindow *) 0 ;
56450 int arg3 = (int) 0 ;
56451 void *argp1 = 0 ;
56452 int res1 = 0 ;
56453 void *argp2 = 0 ;
56454 int res2 = 0 ;
56455 int val3 ;
56456 int ecode3 = 0 ;
56457 PyObject * obj0 = 0 ;
56458 PyObject * obj1 = 0 ;
56459 PyObject * obj2 = 0 ;
56460 char * kwnames[] = {
56461 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56462 };
56463
56464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56466 if (!SWIG_IsOK(res1)) {
56467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56468 }
56469 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56471 if (!SWIG_IsOK(res2)) {
56472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56473 }
56474 arg2 = reinterpret_cast< wxWindow * >(argp2);
56475 if (obj2) {
56476 ecode3 = SWIG_AsVal_int(obj2, &val3);
56477 if (!SWIG_IsOK(ecode3)) {
56478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
56479 }
56480 arg3 = static_cast< int >(val3);
56481 }
56482 {
56483 PyThreadState* __tstate = wxPyBeginAllowThreads();
56484 (arg1)->RightOf(arg2,arg3);
56485 wxPyEndAllowThreads(__tstate);
56486 if (PyErr_Occurred()) SWIG_fail;
56487 }
56488 resultobj = SWIG_Py_Void();
56489 return resultobj;
56490 fail:
56491 return NULL;
56492 }
56493
56494
56495 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56496 PyObject *resultobj = 0;
56497 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56498 wxWindow *arg2 = (wxWindow *) 0 ;
56499 int arg3 = (int) 0 ;
56500 void *argp1 = 0 ;
56501 int res1 = 0 ;
56502 void *argp2 = 0 ;
56503 int res2 = 0 ;
56504 int val3 ;
56505 int ecode3 = 0 ;
56506 PyObject * obj0 = 0 ;
56507 PyObject * obj1 = 0 ;
56508 PyObject * obj2 = 0 ;
56509 char * kwnames[] = {
56510 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56511 };
56512
56513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56515 if (!SWIG_IsOK(res1)) {
56516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56517 }
56518 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56520 if (!SWIG_IsOK(res2)) {
56521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
56522 }
56523 arg2 = reinterpret_cast< wxWindow * >(argp2);
56524 if (obj2) {
56525 ecode3 = SWIG_AsVal_int(obj2, &val3);
56526 if (!SWIG_IsOK(ecode3)) {
56527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
56528 }
56529 arg3 = static_cast< int >(val3);
56530 }
56531 {
56532 PyThreadState* __tstate = wxPyBeginAllowThreads();
56533 (arg1)->Above(arg2,arg3);
56534 wxPyEndAllowThreads(__tstate);
56535 if (PyErr_Occurred()) SWIG_fail;
56536 }
56537 resultobj = SWIG_Py_Void();
56538 return resultobj;
56539 fail:
56540 return NULL;
56541 }
56542
56543
56544 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56545 PyObject *resultobj = 0;
56546 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56547 wxWindow *arg2 = (wxWindow *) 0 ;
56548 int arg3 = (int) 0 ;
56549 void *argp1 = 0 ;
56550 int res1 = 0 ;
56551 void *argp2 = 0 ;
56552 int res2 = 0 ;
56553 int val3 ;
56554 int ecode3 = 0 ;
56555 PyObject * obj0 = 0 ;
56556 PyObject * obj1 = 0 ;
56557 PyObject * obj2 = 0 ;
56558 char * kwnames[] = {
56559 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56560 };
56561
56562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56564 if (!SWIG_IsOK(res1)) {
56565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56566 }
56567 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56569 if (!SWIG_IsOK(res2)) {
56570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
56571 }
56572 arg2 = reinterpret_cast< wxWindow * >(argp2);
56573 if (obj2) {
56574 ecode3 = SWIG_AsVal_int(obj2, &val3);
56575 if (!SWIG_IsOK(ecode3)) {
56576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
56577 }
56578 arg3 = static_cast< int >(val3);
56579 }
56580 {
56581 PyThreadState* __tstate = wxPyBeginAllowThreads();
56582 (arg1)->Below(arg2,arg3);
56583 wxPyEndAllowThreads(__tstate);
56584 if (PyErr_Occurred()) SWIG_fail;
56585 }
56586 resultobj = SWIG_Py_Void();
56587 return resultobj;
56588 fail:
56589 return NULL;
56590 }
56591
56592
56593 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56594 PyObject *resultobj = 0;
56595 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56596 wxWindow *arg2 = (wxWindow *) 0 ;
56597 wxEdge arg3 ;
56598 int arg4 = (int) 0 ;
56599 void *argp1 = 0 ;
56600 int res1 = 0 ;
56601 void *argp2 = 0 ;
56602 int res2 = 0 ;
56603 int val3 ;
56604 int ecode3 = 0 ;
56605 int val4 ;
56606 int ecode4 = 0 ;
56607 PyObject * obj0 = 0 ;
56608 PyObject * obj1 = 0 ;
56609 PyObject * obj2 = 0 ;
56610 PyObject * obj3 = 0 ;
56611 char * kwnames[] = {
56612 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
56613 };
56614
56615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56617 if (!SWIG_IsOK(res1)) {
56618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56619 }
56620 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56622 if (!SWIG_IsOK(res2)) {
56623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
56624 }
56625 arg2 = reinterpret_cast< wxWindow * >(argp2);
56626 ecode3 = SWIG_AsVal_int(obj2, &val3);
56627 if (!SWIG_IsOK(ecode3)) {
56628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
56629 }
56630 arg3 = static_cast< wxEdge >(val3);
56631 if (obj3) {
56632 ecode4 = SWIG_AsVal_int(obj3, &val4);
56633 if (!SWIG_IsOK(ecode4)) {
56634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
56635 }
56636 arg4 = static_cast< int >(val4);
56637 }
56638 {
56639 PyThreadState* __tstate = wxPyBeginAllowThreads();
56640 (arg1)->SameAs(arg2,arg3,arg4);
56641 wxPyEndAllowThreads(__tstate);
56642 if (PyErr_Occurred()) SWIG_fail;
56643 }
56644 resultobj = SWIG_Py_Void();
56645 return resultobj;
56646 fail:
56647 return NULL;
56648 }
56649
56650
56651 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56652 PyObject *resultobj = 0;
56653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56654 wxWindow *arg2 = (wxWindow *) 0 ;
56655 wxEdge arg3 ;
56656 int arg4 ;
56657 void *argp1 = 0 ;
56658 int res1 = 0 ;
56659 void *argp2 = 0 ;
56660 int res2 = 0 ;
56661 int val3 ;
56662 int ecode3 = 0 ;
56663 int val4 ;
56664 int ecode4 = 0 ;
56665 PyObject * obj0 = 0 ;
56666 PyObject * obj1 = 0 ;
56667 PyObject * obj2 = 0 ;
56668 PyObject * obj3 = 0 ;
56669 char * kwnames[] = {
56670 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
56671 };
56672
56673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56675 if (!SWIG_IsOK(res1)) {
56676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56677 }
56678 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56679 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56680 if (!SWIG_IsOK(res2)) {
56681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56682 }
56683 arg2 = reinterpret_cast< wxWindow * >(argp2);
56684 ecode3 = SWIG_AsVal_int(obj2, &val3);
56685 if (!SWIG_IsOK(ecode3)) {
56686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
56687 }
56688 arg3 = static_cast< wxEdge >(val3);
56689 ecode4 = SWIG_AsVal_int(obj3, &val4);
56690 if (!SWIG_IsOK(ecode4)) {
56691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
56692 }
56693 arg4 = static_cast< int >(val4);
56694 {
56695 PyThreadState* __tstate = wxPyBeginAllowThreads();
56696 (arg1)->PercentOf(arg2,arg3,arg4);
56697 wxPyEndAllowThreads(__tstate);
56698 if (PyErr_Occurred()) SWIG_fail;
56699 }
56700 resultobj = SWIG_Py_Void();
56701 return resultobj;
56702 fail:
56703 return NULL;
56704 }
56705
56706
56707 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56708 PyObject *resultobj = 0;
56709 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56710 int arg2 ;
56711 void *argp1 = 0 ;
56712 int res1 = 0 ;
56713 int val2 ;
56714 int ecode2 = 0 ;
56715 PyObject * obj0 = 0 ;
56716 PyObject * obj1 = 0 ;
56717 char * kwnames[] = {
56718 (char *) "self",(char *) "val", NULL
56719 };
56720
56721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
56722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56723 if (!SWIG_IsOK(res1)) {
56724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56725 }
56726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56727 ecode2 = SWIG_AsVal_int(obj1, &val2);
56728 if (!SWIG_IsOK(ecode2)) {
56729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
56730 }
56731 arg2 = static_cast< int >(val2);
56732 {
56733 PyThreadState* __tstate = wxPyBeginAllowThreads();
56734 (arg1)->Absolute(arg2);
56735 wxPyEndAllowThreads(__tstate);
56736 if (PyErr_Occurred()) SWIG_fail;
56737 }
56738 resultobj = SWIG_Py_Void();
56739 return resultobj;
56740 fail:
56741 return NULL;
56742 }
56743
56744
56745 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56746 PyObject *resultobj = 0;
56747 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56748 void *argp1 = 0 ;
56749 int res1 = 0 ;
56750 PyObject *swig_obj[1] ;
56751
56752 if (!args) SWIG_fail;
56753 swig_obj[0] = args;
56754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56755 if (!SWIG_IsOK(res1)) {
56756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56757 }
56758 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56759 {
56760 PyThreadState* __tstate = wxPyBeginAllowThreads();
56761 (arg1)->Unconstrained();
56762 wxPyEndAllowThreads(__tstate);
56763 if (PyErr_Occurred()) SWIG_fail;
56764 }
56765 resultobj = SWIG_Py_Void();
56766 return resultobj;
56767 fail:
56768 return NULL;
56769 }
56770
56771
56772 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56773 PyObject *resultobj = 0;
56774 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56775 void *argp1 = 0 ;
56776 int res1 = 0 ;
56777 PyObject *swig_obj[1] ;
56778
56779 if (!args) SWIG_fail;
56780 swig_obj[0] = args;
56781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56782 if (!SWIG_IsOK(res1)) {
56783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56784 }
56785 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56786 {
56787 PyThreadState* __tstate = wxPyBeginAllowThreads();
56788 (arg1)->AsIs();
56789 wxPyEndAllowThreads(__tstate);
56790 if (PyErr_Occurred()) SWIG_fail;
56791 }
56792 resultobj = SWIG_Py_Void();
56793 return resultobj;
56794 fail:
56795 return NULL;
56796 }
56797
56798
56799 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56800 PyObject *resultobj = 0;
56801 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56802 wxWindow *result = 0 ;
56803 void *argp1 = 0 ;
56804 int res1 = 0 ;
56805 PyObject *swig_obj[1] ;
56806
56807 if (!args) SWIG_fail;
56808 swig_obj[0] = args;
56809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56810 if (!SWIG_IsOK(res1)) {
56811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56812 }
56813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56814 {
56815 PyThreadState* __tstate = wxPyBeginAllowThreads();
56816 result = (wxWindow *)(arg1)->GetOtherWindow();
56817 wxPyEndAllowThreads(__tstate);
56818 if (PyErr_Occurred()) SWIG_fail;
56819 }
56820 {
56821 resultobj = wxPyMake_wxObject(result, 0);
56822 }
56823 return resultobj;
56824 fail:
56825 return NULL;
56826 }
56827
56828
56829 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56830 PyObject *resultobj = 0;
56831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56832 wxEdge result;
56833 void *argp1 = 0 ;
56834 int res1 = 0 ;
56835 PyObject *swig_obj[1] ;
56836
56837 if (!args) SWIG_fail;
56838 swig_obj[0] = args;
56839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56840 if (!SWIG_IsOK(res1)) {
56841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56842 }
56843 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56844 {
56845 PyThreadState* __tstate = wxPyBeginAllowThreads();
56846 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
56847 wxPyEndAllowThreads(__tstate);
56848 if (PyErr_Occurred()) SWIG_fail;
56849 }
56850 resultobj = SWIG_From_int(static_cast< int >(result));
56851 return resultobj;
56852 fail:
56853 return NULL;
56854 }
56855
56856
56857 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56858 PyObject *resultobj = 0;
56859 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56860 wxEdge arg2 ;
56861 void *argp1 = 0 ;
56862 int res1 = 0 ;
56863 int val2 ;
56864 int ecode2 = 0 ;
56865 PyObject * obj0 = 0 ;
56866 PyObject * obj1 = 0 ;
56867 char * kwnames[] = {
56868 (char *) "self",(char *) "which", NULL
56869 };
56870
56871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
56872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56873 if (!SWIG_IsOK(res1)) {
56874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56875 }
56876 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56877 ecode2 = SWIG_AsVal_int(obj1, &val2);
56878 if (!SWIG_IsOK(ecode2)) {
56879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56880 }
56881 arg2 = static_cast< wxEdge >(val2);
56882 {
56883 PyThreadState* __tstate = wxPyBeginAllowThreads();
56884 (arg1)->SetEdge(arg2);
56885 wxPyEndAllowThreads(__tstate);
56886 if (PyErr_Occurred()) SWIG_fail;
56887 }
56888 resultobj = SWIG_Py_Void();
56889 return resultobj;
56890 fail:
56891 return NULL;
56892 }
56893
56894
56895 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56896 PyObject *resultobj = 0;
56897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56898 int arg2 ;
56899 void *argp1 = 0 ;
56900 int res1 = 0 ;
56901 int val2 ;
56902 int ecode2 = 0 ;
56903 PyObject * obj0 = 0 ;
56904 PyObject * obj1 = 0 ;
56905 char * kwnames[] = {
56906 (char *) "self",(char *) "v", NULL
56907 };
56908
56909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
56910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56911 if (!SWIG_IsOK(res1)) {
56912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56913 }
56914 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56915 ecode2 = SWIG_AsVal_int(obj1, &val2);
56916 if (!SWIG_IsOK(ecode2)) {
56917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
56918 }
56919 arg2 = static_cast< int >(val2);
56920 {
56921 PyThreadState* __tstate = wxPyBeginAllowThreads();
56922 (arg1)->SetValue(arg2);
56923 wxPyEndAllowThreads(__tstate);
56924 if (PyErr_Occurred()) SWIG_fail;
56925 }
56926 resultobj = SWIG_Py_Void();
56927 return resultobj;
56928 fail:
56929 return NULL;
56930 }
56931
56932
56933 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56934 PyObject *resultobj = 0;
56935 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56936 int result;
56937 void *argp1 = 0 ;
56938 int res1 = 0 ;
56939 PyObject *swig_obj[1] ;
56940
56941 if (!args) SWIG_fail;
56942 swig_obj[0] = args;
56943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56944 if (!SWIG_IsOK(res1)) {
56945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56946 }
56947 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56948 {
56949 PyThreadState* __tstate = wxPyBeginAllowThreads();
56950 result = (int)(arg1)->GetMargin();
56951 wxPyEndAllowThreads(__tstate);
56952 if (PyErr_Occurred()) SWIG_fail;
56953 }
56954 resultobj = SWIG_From_int(static_cast< int >(result));
56955 return resultobj;
56956 fail:
56957 return NULL;
56958 }
56959
56960
56961 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56962 PyObject *resultobj = 0;
56963 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56964 int arg2 ;
56965 void *argp1 = 0 ;
56966 int res1 = 0 ;
56967 int val2 ;
56968 int ecode2 = 0 ;
56969 PyObject * obj0 = 0 ;
56970 PyObject * obj1 = 0 ;
56971 char * kwnames[] = {
56972 (char *) "self",(char *) "m", NULL
56973 };
56974
56975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
56976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56977 if (!SWIG_IsOK(res1)) {
56978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56979 }
56980 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56981 ecode2 = SWIG_AsVal_int(obj1, &val2);
56982 if (!SWIG_IsOK(ecode2)) {
56983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
56984 }
56985 arg2 = static_cast< int >(val2);
56986 {
56987 PyThreadState* __tstate = wxPyBeginAllowThreads();
56988 (arg1)->SetMargin(arg2);
56989 wxPyEndAllowThreads(__tstate);
56990 if (PyErr_Occurred()) SWIG_fail;
56991 }
56992 resultobj = SWIG_Py_Void();
56993 return resultobj;
56994 fail:
56995 return NULL;
56996 }
56997
56998
56999 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57000 PyObject *resultobj = 0;
57001 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57002 int result;
57003 void *argp1 = 0 ;
57004 int res1 = 0 ;
57005 PyObject *swig_obj[1] ;
57006
57007 if (!args) SWIG_fail;
57008 swig_obj[0] = args;
57009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57010 if (!SWIG_IsOK(res1)) {
57011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57012 }
57013 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57014 {
57015 PyThreadState* __tstate = wxPyBeginAllowThreads();
57016 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57017 wxPyEndAllowThreads(__tstate);
57018 if (PyErr_Occurred()) SWIG_fail;
57019 }
57020 resultobj = SWIG_From_int(static_cast< int >(result));
57021 return resultobj;
57022 fail:
57023 return NULL;
57024 }
57025
57026
57027 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57028 PyObject *resultobj = 0;
57029 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57030 int result;
57031 void *argp1 = 0 ;
57032 int res1 = 0 ;
57033 PyObject *swig_obj[1] ;
57034
57035 if (!args) SWIG_fail;
57036 swig_obj[0] = args;
57037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57038 if (!SWIG_IsOK(res1)) {
57039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57040 }
57041 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57042 {
57043 PyThreadState* __tstate = wxPyBeginAllowThreads();
57044 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57045 wxPyEndAllowThreads(__tstate);
57046 if (PyErr_Occurred()) SWIG_fail;
57047 }
57048 resultobj = SWIG_From_int(static_cast< int >(result));
57049 return resultobj;
57050 fail:
57051 return NULL;
57052 }
57053
57054
57055 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57056 PyObject *resultobj = 0;
57057 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57058 int result;
57059 void *argp1 = 0 ;
57060 int res1 = 0 ;
57061 PyObject *swig_obj[1] ;
57062
57063 if (!args) SWIG_fail;
57064 swig_obj[0] = args;
57065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57066 if (!SWIG_IsOK(res1)) {
57067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57068 }
57069 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57070 {
57071 PyThreadState* __tstate = wxPyBeginAllowThreads();
57072 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57073 wxPyEndAllowThreads(__tstate);
57074 if (PyErr_Occurred()) SWIG_fail;
57075 }
57076 resultobj = SWIG_From_int(static_cast< int >(result));
57077 return resultobj;
57078 fail:
57079 return NULL;
57080 }
57081
57082
57083 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57084 PyObject *resultobj = 0;
57085 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57086 bool result;
57087 void *argp1 = 0 ;
57088 int res1 = 0 ;
57089 PyObject *swig_obj[1] ;
57090
57091 if (!args) SWIG_fail;
57092 swig_obj[0] = args;
57093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57094 if (!SWIG_IsOK(res1)) {
57095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57096 }
57097 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57098 {
57099 PyThreadState* __tstate = wxPyBeginAllowThreads();
57100 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57101 wxPyEndAllowThreads(__tstate);
57102 if (PyErr_Occurred()) SWIG_fail;
57103 }
57104 {
57105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57106 }
57107 return resultobj;
57108 fail:
57109 return NULL;
57110 }
57111
57112
57113 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57114 PyObject *resultobj = 0;
57115 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57116 bool arg2 ;
57117 void *argp1 = 0 ;
57118 int res1 = 0 ;
57119 bool val2 ;
57120 int ecode2 = 0 ;
57121 PyObject * obj0 = 0 ;
57122 PyObject * obj1 = 0 ;
57123 char * kwnames[] = {
57124 (char *) "self",(char *) "d", NULL
57125 };
57126
57127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57129 if (!SWIG_IsOK(res1)) {
57130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57131 }
57132 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57133 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57134 if (!SWIG_IsOK(ecode2)) {
57135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57136 }
57137 arg2 = static_cast< bool >(val2);
57138 {
57139 PyThreadState* __tstate = wxPyBeginAllowThreads();
57140 (arg1)->SetDone(arg2);
57141 wxPyEndAllowThreads(__tstate);
57142 if (PyErr_Occurred()) SWIG_fail;
57143 }
57144 resultobj = SWIG_Py_Void();
57145 return resultobj;
57146 fail:
57147 return NULL;
57148 }
57149
57150
57151 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57152 PyObject *resultobj = 0;
57153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57154 wxRelationship result;
57155 void *argp1 = 0 ;
57156 int res1 = 0 ;
57157 PyObject *swig_obj[1] ;
57158
57159 if (!args) SWIG_fail;
57160 swig_obj[0] = args;
57161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57162 if (!SWIG_IsOK(res1)) {
57163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57164 }
57165 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57166 {
57167 PyThreadState* __tstate = wxPyBeginAllowThreads();
57168 result = (wxRelationship)(arg1)->GetRelationship();
57169 wxPyEndAllowThreads(__tstate);
57170 if (PyErr_Occurred()) SWIG_fail;
57171 }
57172 resultobj = SWIG_From_int(static_cast< int >(result));
57173 return resultobj;
57174 fail:
57175 return NULL;
57176 }
57177
57178
57179 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57180 PyObject *resultobj = 0;
57181 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57182 wxRelationship arg2 ;
57183 void *argp1 = 0 ;
57184 int res1 = 0 ;
57185 int val2 ;
57186 int ecode2 = 0 ;
57187 PyObject * obj0 = 0 ;
57188 PyObject * obj1 = 0 ;
57189 char * kwnames[] = {
57190 (char *) "self",(char *) "r", NULL
57191 };
57192
57193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57195 if (!SWIG_IsOK(res1)) {
57196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57197 }
57198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57199 ecode2 = SWIG_AsVal_int(obj1, &val2);
57200 if (!SWIG_IsOK(ecode2)) {
57201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57202 }
57203 arg2 = static_cast< wxRelationship >(val2);
57204 {
57205 PyThreadState* __tstate = wxPyBeginAllowThreads();
57206 (arg1)->SetRelationship(arg2);
57207 wxPyEndAllowThreads(__tstate);
57208 if (PyErr_Occurred()) SWIG_fail;
57209 }
57210 resultobj = SWIG_Py_Void();
57211 return resultobj;
57212 fail:
57213 return NULL;
57214 }
57215
57216
57217 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57218 PyObject *resultobj = 0;
57219 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57220 wxWindow *arg2 = (wxWindow *) 0 ;
57221 bool result;
57222 void *argp1 = 0 ;
57223 int res1 = 0 ;
57224 void *argp2 = 0 ;
57225 int res2 = 0 ;
57226 PyObject * obj0 = 0 ;
57227 PyObject * obj1 = 0 ;
57228 char * kwnames[] = {
57229 (char *) "self",(char *) "otherW", NULL
57230 };
57231
57232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57234 if (!SWIG_IsOK(res1)) {
57235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57236 }
57237 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57238 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57239 if (!SWIG_IsOK(res2)) {
57240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57241 }
57242 arg2 = reinterpret_cast< wxWindow * >(argp2);
57243 {
57244 PyThreadState* __tstate = wxPyBeginAllowThreads();
57245 result = (bool)(arg1)->ResetIfWin(arg2);
57246 wxPyEndAllowThreads(__tstate);
57247 if (PyErr_Occurred()) SWIG_fail;
57248 }
57249 {
57250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57251 }
57252 return resultobj;
57253 fail:
57254 return NULL;
57255 }
57256
57257
57258 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57259 PyObject *resultobj = 0;
57260 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57261 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57262 wxWindow *arg3 = (wxWindow *) 0 ;
57263 bool result;
57264 void *argp1 = 0 ;
57265 int res1 = 0 ;
57266 void *argp2 = 0 ;
57267 int res2 = 0 ;
57268 void *argp3 = 0 ;
57269 int res3 = 0 ;
57270 PyObject * obj0 = 0 ;
57271 PyObject * obj1 = 0 ;
57272 PyObject * obj2 = 0 ;
57273 char * kwnames[] = {
57274 (char *) "self",(char *) "constraints",(char *) "win", NULL
57275 };
57276
57277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57279 if (!SWIG_IsOK(res1)) {
57280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57281 }
57282 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57284 if (!SWIG_IsOK(res2)) {
57285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57286 }
57287 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57288 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57289 if (!SWIG_IsOK(res3)) {
57290 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57291 }
57292 arg3 = reinterpret_cast< wxWindow * >(argp3);
57293 {
57294 PyThreadState* __tstate = wxPyBeginAllowThreads();
57295 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57296 wxPyEndAllowThreads(__tstate);
57297 if (PyErr_Occurred()) SWIG_fail;
57298 }
57299 {
57300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57301 }
57302 return resultobj;
57303 fail:
57304 return NULL;
57305 }
57306
57307
57308 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57309 PyObject *resultobj = 0;
57310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57311 wxEdge arg2 ;
57312 wxWindow *arg3 = (wxWindow *) 0 ;
57313 wxWindow *arg4 = (wxWindow *) 0 ;
57314 int result;
57315 void *argp1 = 0 ;
57316 int res1 = 0 ;
57317 int val2 ;
57318 int ecode2 = 0 ;
57319 void *argp3 = 0 ;
57320 int res3 = 0 ;
57321 void *argp4 = 0 ;
57322 int res4 = 0 ;
57323 PyObject * obj0 = 0 ;
57324 PyObject * obj1 = 0 ;
57325 PyObject * obj2 = 0 ;
57326 PyObject * obj3 = 0 ;
57327 char * kwnames[] = {
57328 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57329 };
57330
57331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57333 if (!SWIG_IsOK(res1)) {
57334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57335 }
57336 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57337 ecode2 = SWIG_AsVal_int(obj1, &val2);
57338 if (!SWIG_IsOK(ecode2)) {
57339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57340 }
57341 arg2 = static_cast< wxEdge >(val2);
57342 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57343 if (!SWIG_IsOK(res3)) {
57344 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
57345 }
57346 arg3 = reinterpret_cast< wxWindow * >(argp3);
57347 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
57348 if (!SWIG_IsOK(res4)) {
57349 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
57350 }
57351 arg4 = reinterpret_cast< wxWindow * >(argp4);
57352 {
57353 PyThreadState* __tstate = wxPyBeginAllowThreads();
57354 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
57355 wxPyEndAllowThreads(__tstate);
57356 if (PyErr_Occurred()) SWIG_fail;
57357 }
57358 resultobj = SWIG_From_int(static_cast< int >(result));
57359 return resultobj;
57360 fail:
57361 return NULL;
57362 }
57363
57364
57365 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57366 PyObject *obj;
57367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57368 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
57369 return SWIG_Py_Void();
57370 }
57371
57372 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57373 PyObject *resultobj = 0;
57374 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57375 wxIndividualLayoutConstraint *result = 0 ;
57376 void *argp1 = 0 ;
57377 int res1 = 0 ;
57378 PyObject *swig_obj[1] ;
57379
57380 if (!args) SWIG_fail;
57381 swig_obj[0] = args;
57382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57383 if (!SWIG_IsOK(res1)) {
57384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57385 }
57386 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57387 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
57388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57389 return resultobj;
57390 fail:
57391 return NULL;
57392 }
57393
57394
57395 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57396 PyObject *resultobj = 0;
57397 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57398 wxIndividualLayoutConstraint *result = 0 ;
57399 void *argp1 = 0 ;
57400 int res1 = 0 ;
57401 PyObject *swig_obj[1] ;
57402
57403 if (!args) SWIG_fail;
57404 swig_obj[0] = args;
57405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57406 if (!SWIG_IsOK(res1)) {
57407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57408 }
57409 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57410 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
57411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57412 return resultobj;
57413 fail:
57414 return NULL;
57415 }
57416
57417
57418 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57419 PyObject *resultobj = 0;
57420 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57421 wxIndividualLayoutConstraint *result = 0 ;
57422 void *argp1 = 0 ;
57423 int res1 = 0 ;
57424 PyObject *swig_obj[1] ;
57425
57426 if (!args) SWIG_fail;
57427 swig_obj[0] = args;
57428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57429 if (!SWIG_IsOK(res1)) {
57430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57431 }
57432 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57433 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
57434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57435 return resultobj;
57436 fail:
57437 return NULL;
57438 }
57439
57440
57441 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57442 PyObject *resultobj = 0;
57443 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57444 wxIndividualLayoutConstraint *result = 0 ;
57445 void *argp1 = 0 ;
57446 int res1 = 0 ;
57447 PyObject *swig_obj[1] ;
57448
57449 if (!args) SWIG_fail;
57450 swig_obj[0] = args;
57451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57452 if (!SWIG_IsOK(res1)) {
57453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57454 }
57455 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57456 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
57457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57458 return resultobj;
57459 fail:
57460 return NULL;
57461 }
57462
57463
57464 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57465 PyObject *resultobj = 0;
57466 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57467 wxIndividualLayoutConstraint *result = 0 ;
57468 void *argp1 = 0 ;
57469 int res1 = 0 ;
57470 PyObject *swig_obj[1] ;
57471
57472 if (!args) SWIG_fail;
57473 swig_obj[0] = args;
57474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57475 if (!SWIG_IsOK(res1)) {
57476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57477 }
57478 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57479 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
57480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57481 return resultobj;
57482 fail:
57483 return NULL;
57484 }
57485
57486
57487 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57488 PyObject *resultobj = 0;
57489 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57490 wxIndividualLayoutConstraint *result = 0 ;
57491 void *argp1 = 0 ;
57492 int res1 = 0 ;
57493 PyObject *swig_obj[1] ;
57494
57495 if (!args) SWIG_fail;
57496 swig_obj[0] = args;
57497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57498 if (!SWIG_IsOK(res1)) {
57499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57500 }
57501 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57502 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
57503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57504 return resultobj;
57505 fail:
57506 return NULL;
57507 }
57508
57509
57510 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57511 PyObject *resultobj = 0;
57512 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57513 wxIndividualLayoutConstraint *result = 0 ;
57514 void *argp1 = 0 ;
57515 int res1 = 0 ;
57516 PyObject *swig_obj[1] ;
57517
57518 if (!args) SWIG_fail;
57519 swig_obj[0] = args;
57520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57521 if (!SWIG_IsOK(res1)) {
57522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57523 }
57524 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57525 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
57526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57527 return resultobj;
57528 fail:
57529 return NULL;
57530 }
57531
57532
57533 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57534 PyObject *resultobj = 0;
57535 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57536 wxIndividualLayoutConstraint *result = 0 ;
57537 void *argp1 = 0 ;
57538 int res1 = 0 ;
57539 PyObject *swig_obj[1] ;
57540
57541 if (!args) SWIG_fail;
57542 swig_obj[0] = args;
57543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57544 if (!SWIG_IsOK(res1)) {
57545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57546 }
57547 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57548 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
57549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57550 return resultobj;
57551 fail:
57552 return NULL;
57553 }
57554
57555
57556 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57557 PyObject *resultobj = 0;
57558 wxLayoutConstraints *result = 0 ;
57559
57560 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
57561 {
57562 PyThreadState* __tstate = wxPyBeginAllowThreads();
57563 result = (wxLayoutConstraints *)new wxLayoutConstraints();
57564 wxPyEndAllowThreads(__tstate);
57565 if (PyErr_Occurred()) SWIG_fail;
57566 }
57567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
57568 return resultobj;
57569 fail:
57570 return NULL;
57571 }
57572
57573
57574 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57575 PyObject *resultobj = 0;
57576 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57577 void *argp1 = 0 ;
57578 int res1 = 0 ;
57579 PyObject *swig_obj[1] ;
57580
57581 if (!args) SWIG_fail;
57582 swig_obj[0] = args;
57583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
57584 if (!SWIG_IsOK(res1)) {
57585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57586 }
57587 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57588 {
57589 PyThreadState* __tstate = wxPyBeginAllowThreads();
57590 delete arg1;
57591
57592 wxPyEndAllowThreads(__tstate);
57593 if (PyErr_Occurred()) SWIG_fail;
57594 }
57595 resultobj = SWIG_Py_Void();
57596 return resultobj;
57597 fail:
57598 return NULL;
57599 }
57600
57601
57602 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57603 PyObject *resultobj = 0;
57604 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57605 wxWindow *arg2 = (wxWindow *) 0 ;
57606 int *arg3 = (int *) 0 ;
57607 bool result;
57608 void *argp1 = 0 ;
57609 int res1 = 0 ;
57610 void *argp2 = 0 ;
57611 int res2 = 0 ;
57612 int temp3 ;
57613 int res3 = SWIG_TMPOBJ ;
57614 PyObject * obj0 = 0 ;
57615 PyObject * obj1 = 0 ;
57616 char * kwnames[] = {
57617 (char *) "self",(char *) "win", NULL
57618 };
57619
57620 arg3 = &temp3;
57621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
57622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57623 if (!SWIG_IsOK(res1)) {
57624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57625 }
57626 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57628 if (!SWIG_IsOK(res2)) {
57629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
57630 }
57631 arg2 = reinterpret_cast< wxWindow * >(argp2);
57632 {
57633 PyThreadState* __tstate = wxPyBeginAllowThreads();
57634 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
57635 wxPyEndAllowThreads(__tstate);
57636 if (PyErr_Occurred()) SWIG_fail;
57637 }
57638 {
57639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57640 }
57641 if (SWIG_IsTmpObj(res3)) {
57642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
57643 } else {
57644 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
57645 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
57646 }
57647 return resultobj;
57648 fail:
57649 return NULL;
57650 }
57651
57652
57653 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57654 PyObject *resultobj = 0;
57655 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57656 bool result;
57657 void *argp1 = 0 ;
57658 int res1 = 0 ;
57659 PyObject *swig_obj[1] ;
57660
57661 if (!args) SWIG_fail;
57662 swig_obj[0] = args;
57663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57664 if (!SWIG_IsOK(res1)) {
57665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
57666 }
57667 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57668 {
57669 PyThreadState* __tstate = wxPyBeginAllowThreads();
57670 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
57671 wxPyEndAllowThreads(__tstate);
57672 if (PyErr_Occurred()) SWIG_fail;
57673 }
57674 {
57675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57676 }
57677 return resultobj;
57678 fail:
57679 return NULL;
57680 }
57681
57682
57683 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57684 PyObject *obj;
57685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57686 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
57687 return SWIG_Py_Void();
57688 }
57689
57690 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57691 return SWIG_Python_InitShadowInstance(args);
57692 }
57693
57694 static PyMethodDef SwigMethods[] = {
57695 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
57696 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
57697 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
57698 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
57700 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
57701 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
57702 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
57703 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
57704 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
57706 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
57719 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
57720 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
57721 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
57723 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
57724 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
57725 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
57726 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
57727 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
57728 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
57729 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
57731 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
57737 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
57738 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
57739 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
57740 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
57741 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
57742 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
57743 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
57745 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
57753 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
57754 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
57755 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
57760 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
57761 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
57763 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
57765 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
57767 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
57769 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
57771 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
57773 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
57774 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
57776 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
57778 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
57780 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
57782 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
57783 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
57784 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
57785 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57798 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57802 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
57805 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
57806 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
57807 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
57808 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
57809 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
57810 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
57811 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
57812 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
57814 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
57815 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
57816 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
57821 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
57822 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
57823 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
57824 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
57825 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
57832 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
57839 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
57840 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
57841 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
57842 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
57844 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
57845 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
57846 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
57848 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
57849 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
57850 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
57851 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
57854 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
57857 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
57860 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
57863 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
57866 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
57869 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
57872 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
57875 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
57881 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
57883 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
57892 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
57895 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
57896 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
57897 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
57898 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
57899 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
57900 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
57901 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
57902 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
57904 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
57905 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
57906 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
57908 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
57909 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
57910 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
57911 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
57916 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
57917 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
57918 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
57919 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
57920 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
57921 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
57924 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
57925 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
57926 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
57928 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
57929 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
57931 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
57932 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
57933 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
57934 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
57935 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
57936 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
57937 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
57938 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
57939 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
57940 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
57941 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
57942 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
57947 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
57953 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
57954 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
57955 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
57956 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
57958 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57960 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
57961 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
57964 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
57967 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
57968 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
57969 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57970 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57971 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
57972 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
57973 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
57974 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57977 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
57978 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
57979 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
57980 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
57984 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57986 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57987 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57988 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
57989 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
57990 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
57991 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
57992 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
57993 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
57994 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
57995 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
57996 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
57997 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57998 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
57999 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58000 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58001 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58002 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58003 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58004 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58005 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58006 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58007 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58008 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58013 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58014 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58015 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58016 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58017 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58018 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58019 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58020 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58021 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58022 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58023 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58024 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58025 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58026 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58027 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58028 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58029 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58030 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58031 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58032 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58033 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58034 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58035 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58036 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58037 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58038 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58039 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58040 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58042 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58043 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58044 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58045 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58046 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58047 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58048 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58049 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58050 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58051 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58052 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58053 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58054 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58055 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58056 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58057 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58058 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58059 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58060 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58061 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58062 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58063 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58064 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58065 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58066 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58071 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58072 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58073 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58074 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58075 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58076 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58077 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58078 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58079 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58080 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58081 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58082 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58083 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58084 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58085 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58086 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58087 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58088 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58089 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58090 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58091 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58092 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58093 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58094 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58095 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58096 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58097 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58098 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58099 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58100 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58101 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58102 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58103 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58104 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58105 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58106 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58107 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58108 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58109 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58110 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58111 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58112 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58113 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58114 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58115 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58116 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58117 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58118 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58119 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58120 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58121 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58122 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58123 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58124 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58125 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58126 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58127 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58128 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58129 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58130 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58131 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58132 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58133 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58134 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58135 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58136 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58137 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58138 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58139 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58140 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58141 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58142 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58143 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58144 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58145 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58146 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58147 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58148 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58149 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58150 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58151 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58152 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58153 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58154 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58155 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58156 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58157 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58158 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58159 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58160 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58161 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58162 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58163 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58164 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58165 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58166 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58167 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58168 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58169 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58170 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58171 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58172 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58173 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58174 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58175 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58176 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58177 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58178 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58179 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58180 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58181 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58182 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58183 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58184 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58185 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58186 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58187 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58188 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58189 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58190 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58191 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58192 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58193 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58194 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58195 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58196 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58197 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58198 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58199 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58200 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58201 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58202 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58203 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58204 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58205 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58206 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58207 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58208 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58209 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58210 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58211 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58212 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58213 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58214 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58215 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58216 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58217 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58218 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58219 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58220 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58221 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58222 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58223 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58224 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58225 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58226 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58227 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58228 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58229 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58230 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58231 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58232 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58233 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58234 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58235 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58236 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58237 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58238 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58239 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58240 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58241 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58242 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58243 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58244 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58245 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58246 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58247 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58248 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58249 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58250 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58251 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58252 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58253 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58254 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58255 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58256 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58257 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58258 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58259 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58260 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58261 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58262 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58263 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58264 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58265 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58266 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58267 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58268 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58269 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58270 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58271 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58272 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58273 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58274 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58275 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58276 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58277 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58278 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58279 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58280 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58281 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58282 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58283 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58284 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58285 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58286 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58287 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58288 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58289 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58290 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58291 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58292 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58293 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58294 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58295 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58296 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58297 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58298 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58299 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58300 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58301 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58302 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58303 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58304 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58305 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58306 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58307 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58308 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58309 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58310 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58311 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58312 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58313 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58314 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58315 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58316 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58317 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58318 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58319 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58320 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58321 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58322 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58323 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58324 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58325 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58326 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58327 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58328 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58329 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
58330 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
58331 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
58332 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
58333 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
58334 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
58335 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
58336 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
58337 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
58338 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
58339 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
58340 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
58341 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
58342 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
58343 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
58344 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
58345 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
58346 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
58347 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
58348 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
58349 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
58350 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58351 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
58352 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
58353 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58354 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58355 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
58356 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
58357 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
58358 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
58359 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
58360 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
58361 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58362 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
58363 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
58364 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58365 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58366 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
58367 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
58368 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58369 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
58370 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
58371 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58372 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
58373 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
58374 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58375 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
58376 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
58377 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
58378 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58379 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
58380 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58381 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
58382 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
58383 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58384 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
58385 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
58386 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
58387 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58388 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
58389 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
58390 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
58391 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58392 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
58393 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
58394 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58395 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
58396 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
58397 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
58398 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
58399 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
58400 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58401 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
58402 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
58403 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
58404 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
58405 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
58406 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
58407 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
58408 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
58409 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58410 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
58411 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
58412 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
58413 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
58414 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58415 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
58416 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
58417 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
58418 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58419 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
58420 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
58421 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
58422 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
58423 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
58424 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
58425 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58426 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
58427 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
58428 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
58429 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
58430 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
58431 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
58432 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
58433 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
58434 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58435 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58436 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58437 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58438 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
58439 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
58440 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
58441 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
58442 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58443 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
58444 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
58445 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
58446 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
58447 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
58448 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
58449 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58450 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
58451 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
58452 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
58453 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58454 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
58455 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
58456 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
58457 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
58458 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
58459 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58460 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58461 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
58462 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
58463 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
58464 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58465 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
58466 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
58467 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
58468 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
58469 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
58470 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
58471 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58472 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
58473 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
58474 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
58475 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
58476 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
58477 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
58478 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
58479 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
58480 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
58481 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58482 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
58483 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
58484 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
58485 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58486 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
58487 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
58488 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
58489 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58490 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
58491 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58492 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
58493 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
58494 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
58495 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
58496 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
58497 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58498 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
58499 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
58500 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
58501 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
58502 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58503 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
58504 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
58505 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58506 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
58507 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58508 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
58509 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
58510 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
58511 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58512 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
58513 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58514 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
58515 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
58516 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
58517 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
58519 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
58520 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
58521 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
58522 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
58523 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
58524 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
58525 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
58526 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
58527 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
58528 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
58529 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58530 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
58531 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
58532 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
58533 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
58534 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
58535 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
58536 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
58537 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
58538 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
58539 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
58540 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
58541 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
58542 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
58543 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
58544 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
58545 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
58546 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
58547 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
58548 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
58549 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
58550 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58551 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
58552 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
58553 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
58554 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
58555 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
58556 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
58557 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
58558 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
58559 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
58560 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
58561 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
58562 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
58563 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
58564 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
58565 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
58566 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58567 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58568 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58569 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
58570 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
58571 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
58572 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
58573 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
58574 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
58575 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
58576 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
58577 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
58578 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
58579 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
58580 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58581 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
58582 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
58583 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
58584 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
58585 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
58586 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
58587 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
58588 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
58589 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
58590 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
58591 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
58592 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
58593 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
58594 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
58595 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
58596 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
58597 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
58598 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
58599 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
58600 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
58601 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
58602 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58603 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58604 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
58605 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
58606 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
58607 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
58608 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
58609 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
58610 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
58611 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
58612 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58613 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
58614 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
58615 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
58616 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
58617 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
58618 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
58619 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
58620 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
58621 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
58622 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
58623 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
58624 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
58625 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
58626 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
58627 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
58628 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
58629 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58630 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
58631 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
58632 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
58633 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
58634 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58635 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
58636 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58637 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
58638 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
58639 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
58640 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
58642 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
58643 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58644 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58645 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
58646 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58647 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58648 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58649 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
58650 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58651 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58652 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
58653 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
58654 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
58656 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
58657 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
58658 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58659 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
58660 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
58661 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
58662 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
58663 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
58664 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
58665 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
58666 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
58667 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
58668 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
58669 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
58670 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
58671 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
58672 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
58673 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
58674 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
58675 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
58676 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
58677 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
58678 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
58679 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
58680 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
58681 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58682 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58683 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58684 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58685 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
58686 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
58687 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
58688 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
58689 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
58690 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
58691 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
58692 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
58693 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58694 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58695 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
58696 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
58697 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
58698 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
58699 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58700 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
58701 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58702 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
58703 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
58704 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
58705 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
58706 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
58707 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58708 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
58709 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
58711 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58712 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58713 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
58714 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58716 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
58717 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
58718 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
58719 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
58720 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
58721 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
58722 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
58723 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
58724 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
58725 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58727 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
58729 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
58730 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
58731 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
58732 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
58733 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
58735 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
58740 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58743 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58744 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
58745 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
58746 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
58747 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
58748 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
58749 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
58750 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
58752 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58754 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58755 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58756 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
58757 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
58758 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58759 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58760 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
58761 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
58762 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
58763 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
58764 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
58765 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
58766 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
58767 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
58768 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
58769 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
58770 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
58771 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
58772 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
58773 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
58774 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
58775 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
58776 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
58779 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
58780 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58783 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58784 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58785 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
58786 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
58787 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
58788 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
58789 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
58791 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
58792 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58793 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
58794 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58795 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
58796 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
58797 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
58798 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
58799 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
58800 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
58801 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58802 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
58810 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
58812 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58813 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
58814 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
58815 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
58817 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58818 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58819 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58820 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58821 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
58822 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
58823 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58824 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
58825 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
58826 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
58827 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
58828 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
58829 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
58830 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
58832 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58833 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
58834 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
58835 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
58836 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
58837 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
58839 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
58842 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
58843 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
58844 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
58845 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58846 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
58847 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
58848 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
58850 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
58851 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
58852 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
58853 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58854 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
58855 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
58856 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58857 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58859 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
58860 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
58861 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
58862 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
58863 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
58864 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
58865 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
58866 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
58867 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58868 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
58869 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
58871 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
58872 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
58873 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58874 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
58875 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
58876 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
58877 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
58878 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
58879 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58880 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58881 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58882 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58883 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
58884 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
58885 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
58886 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
58887 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
58888 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
58889 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58890 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58891 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58892 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
58893 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
58894 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58895 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58896 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58897 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
58898 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
58899 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
58900 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
58901 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
58902 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
58903 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
58904 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
58905 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
58906 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
58908 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
58913 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58916 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58917 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
58918 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
58919 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58920 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
58921 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58922 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
58923 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
58924 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
58925 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
58926 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
58927 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
58928 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
58929 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
58930 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
58931 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
58932 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
58933 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
58935 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
58936 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
58937 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58938 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
58941 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
58942 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
58943 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
58944 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
58945 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
58946 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58947 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58948 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58949 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
58950 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58951 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58952 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58953 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58954 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58955 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
58956 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
58957 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
58958 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
58959 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
58960 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58961 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
58962 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
58963 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
58964 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
58965 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
58966 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
58967 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58968 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58969 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
58970 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
58971 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58972 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
58973 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
58974 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
58975 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
58976 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
58978 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
58979 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
58980 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
58982 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58983 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
58984 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58985 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
58986 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
58987 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
58988 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
58989 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
58990 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
58991 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58992 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
58993 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58994 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
58995 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
58996 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
58997 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58998 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
58999 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59000 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59001 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59002 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59003 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59004 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59005 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59006 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59007 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59008 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59009 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59010 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59011 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59012 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59013 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59014 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59015 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59016 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59017 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59018 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59019 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59020 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59021 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59022 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59023 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59024 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59025 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59026 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59027 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59028 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59029 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59030 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59031 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59032 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59033 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59034 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59035 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59036 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59037 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59038 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59039 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59040 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59041 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59042 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59043 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59044 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59045 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59046 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59047 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59048 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59049 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59050 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59051 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59052 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59053 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59054 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59055 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59056 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59057 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59058 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59059 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59060 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59061 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59062 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59063 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59064 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59065 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59066 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59067 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59068 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59069 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59070 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59071 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59072 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59073 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59074 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59075 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59076 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59077 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59078 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59079 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59080 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59081 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59082 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59083 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59084 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59085 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59086 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59087 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59088 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59089 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59090 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59091 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59092 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59093 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59094 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59095 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59097 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59098 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59099 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59100 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59101 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59102 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59103 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59104 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59107 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59108 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59109 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59110 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59111 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59112 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59113 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59114 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59115 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59116 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59117 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59118 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59119 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59120 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59121 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59122 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59123 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59125 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59126 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59127 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59128 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59129 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59130 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59131 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59132 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59133 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59134 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59135 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59136 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59137 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59138 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59139 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59140 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59141 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59142 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59143 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59144 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59145 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59146 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59147 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59148 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59149 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59150 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59151 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59152 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59153 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59154 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59155 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59156 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59157 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59158 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59159 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59160 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59161 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59162 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59163 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59164 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59165 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59166 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59168 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59169 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59170 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59171 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59172 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59173 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59174 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59175 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59176 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59177 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59178 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59179 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59180 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59182 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59183 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59184 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59185 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59186 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59187 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59188 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59189 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59190 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59191 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59192 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59193 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59194 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59195 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59196 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59197 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59198 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59199 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59200 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59202 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59203 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59204 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59205 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59206 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59207 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59208 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59209 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59210 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59211 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59212 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59213 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59214 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59215 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59216 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59217 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59218 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59219 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59221 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59222 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59223 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59224 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59225 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59226 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59227 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59228 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59229 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59230 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59231 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59232 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59233 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59234 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59235 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59236 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59237 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59238 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59239 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59240 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59241 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59242 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59243 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59244 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59245 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59246 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59247 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59248 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59249 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59250 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59251 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59252 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59253 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59254 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59255 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59256 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59257 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59258 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59259 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59260 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59261 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59262 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59263 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59264 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59265 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59266 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59267 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59268 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59269 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59270 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59271 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59273 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59275 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59276 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59277 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59278 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59279 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59280 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59281 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59282 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59283 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59284 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59285 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59286 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59287 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59288 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59289 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59290 { NULL, NULL, 0, NULL }
59291 };
59292
59293
59294 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59295
59296 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59297 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59298 }
59299 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59300 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59301 }
59302 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59303 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59304 }
59305 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59306 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59307 }
59308 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59309 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59310 }
59311 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59312 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59313 }
59314 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59315 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59316 }
59317 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59319 }
59320 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59321 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59322 }
59323 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59324 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59325 }
59326 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59327 return (void *)((wxEvent *) ((wxPyEvent *) x));
59328 }
59329 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
59330 return (void *)((wxEvent *) ((wxIdleEvent *) x));
59331 }
59332 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
59333 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
59334 }
59335 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
59336 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
59337 }
59338 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
59339 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
59340 }
59341 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
59342 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
59343 }
59344 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
59345 return (void *)((wxEvent *) ((wxActivateEvent *) x));
59346 }
59347 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
59348 return (void *)((wxEvent *) ((wxSizeEvent *) x));
59349 }
59350 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
59351 return (void *)((wxEvent *) ((wxMoveEvent *) x));
59352 }
59353 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
59354 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
59355 }
59356 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
59357 return (void *)((wxEvent *) ((wxPaintEvent *) x));
59358 }
59359 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
59360 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
59361 }
59362 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
59363 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
59364 }
59365 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
59366 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
59367 }
59368 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
59369 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
59370 }
59371 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
59372 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
59373 }
59374 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
59375 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59376 }
59377 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
59378 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
59379 }
59380 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
59381 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
59382 }
59383 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
59384 return (void *)((wxEvent *) ((wxFocusEvent *) x));
59385 }
59386 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
59387 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
59388 }
59389 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
59390 return (void *)((wxEvent *) ((wxShowEvent *) x));
59391 }
59392 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
59393 return (void *)((wxEvent *) ((wxCommandEvent *) x));
59394 }
59395 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
59396 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
59397 }
59398 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
59399 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59400 }
59401 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
59402 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
59403 }
59404 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
59405 return (void *)((wxEvent *) ((wxKeyEvent *) x));
59406 }
59407 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
59408 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
59409 }
59410 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
59411 return (void *)((wxValidator *) ((wxPyValidator *) x));
59412 }
59413 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
59414 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
59415 }
59416 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
59417 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
59418 }
59419 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
59420 return (void *)((wxObject *) ((wxSizerItem *) x));
59421 }
59422 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
59423 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
59424 }
59425 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
59426 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
59427 }
59428 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
59429 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
59430 }
59431 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
59432 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
59433 }
59434 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
59435 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
59436 }
59437 static void *_p_wxSizerTo_p_wxObject(void *x) {
59438 return (void *)((wxObject *) ((wxSizer *) x));
59439 }
59440 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
59441 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59442 }
59443 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
59444 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
59445 }
59446 static void *_p_wxEventTo_p_wxObject(void *x) {
59447 return (void *)((wxObject *) ((wxEvent *) x));
59448 }
59449 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
59450 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
59451 }
59452 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
59453 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
59454 }
59455 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
59456 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
59457 }
59458 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
59459 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
59460 }
59461 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
59462 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
59463 }
59464 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
59465 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
59466 }
59467 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
59468 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
59469 }
59470 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
59471 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
59472 }
59473 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
59474 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59475 }
59476 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
59477 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
59478 }
59479 static void *_p_wxControlTo_p_wxObject(void *x) {
59480 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
59481 }
59482 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
59483 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
59484 }
59485 static void *_p_wxFSFileTo_p_wxObject(void *x) {
59486 return (void *)((wxObject *) ((wxFSFile *) x));
59487 }
59488 static void *_p_wxPySizerTo_p_wxObject(void *x) {
59489 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
59490 }
59491 static void *_p_wxPyEventTo_p_wxObject(void *x) {
59492 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
59493 }
59494 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
59495 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
59496 }
59497 static void *_p_wxShowEventTo_p_wxObject(void *x) {
59498 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
59499 }
59500 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
59501 return (void *)((wxObject *) ((wxMenuItem *) x));
59502 }
59503 static void *_p_wxDateEventTo_p_wxObject(void *x) {
59504 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
59505 }
59506 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
59507 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
59508 }
59509 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
59510 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
59511 }
59512 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
59513 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
59514 }
59515 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
59516 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
59517 }
59518 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
59519 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
59520 }
59521 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
59522 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
59523 }
59524 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
59525 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
59526 }
59527 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
59528 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
59529 }
59530 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
59531 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
59532 }
59533 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
59534 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
59535 }
59536 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
59537 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
59538 }
59539 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
59540 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
59541 }
59542 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
59543 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
59544 }
59545 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
59546 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59547 }
59548 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
59549 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59550 }
59551 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
59552 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
59553 }
59554 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
59555 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
59556 }
59557 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
59558 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
59559 }
59560 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
59561 return (void *)((wxObject *) ((wxImageHandler *) x));
59562 }
59563 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
59564 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
59565 }
59566 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
59567 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
59568 }
59569 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
59570 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
59571 }
59572 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
59573 return (void *)((wxObject *) ((wxEvtHandler *) x));
59574 }
59575 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
59576 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
59577 }
59578 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
59579 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
59580 }
59581 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
59582 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59583 }
59584 static void *_p_wxImageTo_p_wxObject(void *x) {
59585 return (void *)((wxObject *) ((wxImage *) x));
59586 }
59587 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
59588 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
59589 }
59590 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
59591 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59592 }
59593 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
59594 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
59595 }
59596 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
59597 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
59598 }
59599 static void *_p_wxWindowTo_p_wxObject(void *x) {
59600 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
59601 }
59602 static void *_p_wxMenuTo_p_wxObject(void *x) {
59603 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
59604 }
59605 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
59606 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
59607 }
59608 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
59609 return (void *)((wxObject *) ((wxFileSystem *) x));
59610 }
59611 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
59612 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
59613 }
59614 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
59615 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
59616 }
59617 static void *_p_wxPyAppTo_p_wxObject(void *x) {
59618 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
59619 }
59620 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
59621 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
59622 }
59623 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
59624 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
59625 }
59626 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
59627 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
59628 }
59629 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
59630 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
59631 }
59632 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
59633 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
59634 }
59635 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
59636 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
59637 }
59638 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
59639 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
59640 }
59641 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
59642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
59643 }
59644 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
59645 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59646 }
59647 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
59648 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
59649 }
59650 static void *_p_wxValidatorTo_p_wxObject(void *x) {
59651 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
59652 }
59653 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
59654 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
59655 }
59656 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
59657 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
59658 }
59659 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
59660 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
59661 }
59662 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
59663 return (void *)((wxControl *) ((wxControlWithItems *) x));
59664 }
59665 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
59666 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
59667 }
59668 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
59669 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
59670 }
59671 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
59672 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59673 }
59674 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
59675 return (void *)((wxSizer *) ((wxBoxSizer *) x));
59676 }
59677 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
59678 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
59679 }
59680 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
59681 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59682 }
59683 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
59684 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59685 }
59686 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
59687 return (void *)((wxSizer *) ((wxGridSizer *) x));
59688 }
59689 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
59690 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
59691 }
59692 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
59693 return (void *)((wxSizer *) ((wxPySizer *) x));
59694 }
59695 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
59696 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
59697 }
59698 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
59699 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
59700 }
59701 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
59702 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
59703 }
59704 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
59705 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
59706 }
59707 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
59708 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
59709 }
59710 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
59711 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
59712 }
59713 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
59714 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
59715 }
59716 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
59717 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
59718 }
59719 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
59720 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59721 }
59722 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
59723 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59724 }
59725 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
59726 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
59727 }
59728 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
59729 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
59730 }
59731 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
59732 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
59733 }
59734 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
59735 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
59736 }
59737 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
59738 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
59739 }
59740 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
59741 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
59742 }
59743 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
59744 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
59745 }
59746 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
59747 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
59748 }
59749 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
59750 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
59751 }
59752 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
59753 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
59754 }
59755 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
59756 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59757 }
59758 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
59759 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
59760 }
59761 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
59762 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
59763 }
59764 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
59765 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
59766 }
59767 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
59768 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
59769 }
59770 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
59771 return (void *)((wxEvtHandler *) ((wxWindow *) x));
59772 }
59773 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
59774 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59775 }
59776 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
59777 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
59778 }
59779 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
59780 return (void *)((wxEvtHandler *) ((wxValidator *) x));
59781 }
59782 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
59783 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
59784 }
59785 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
59786 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
59787 }
59788 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
59789 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
59790 }
59791 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
59792 return (void *)((wxEvtHandler *) ((wxMenu *) x));
59793 }
59794 static void *_p_wxControlTo_p_wxWindow(void *x) {
59795 return (void *)((wxWindow *) ((wxControl *) x));
59796 }
59797 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
59798 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
59799 }
59800 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
59801 return (void *)((wxWindow *) ((wxMenuBar *) x));
59802 }
59803 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
59804 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
59805 }
59806 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
59807 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
59808 }
59809 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
59810 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
59811 }
59812 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
59813 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
59814 }
59815 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
59816 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
59817 }
59818 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
59819 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
59820 }
59821 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
59822 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59823 }
59824 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
59825 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
59826 }
59827 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
59828 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
59829 }
59830 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
59831 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
59832 }
59833 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
59834 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
59835 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};
59836 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
59837 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
59838 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
59839 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
59840 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
59841 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
59842 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
59843 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
59844 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
59845 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
59846 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
59847 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
59848 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
59849 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
59850 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
59851 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
59852 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
59853 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
59854 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
59855 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
59856 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
59857 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
59858 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
59859 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
59860 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
59861 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
59862 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
59863 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
59864 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
59865 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
59866 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
59867 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
59868 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
59869 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
59870 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
59871 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
59872 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
59873 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
59874 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
59875 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
59876 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
59877 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
59878 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
59879 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
59880 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
59881 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
59882 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
59883 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
59884 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
59885 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
59886 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
59887 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
59888 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
59889 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
59890 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
59891 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
59892 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
59893 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
59894 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
59895 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
59896 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
59897 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
59898 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
59899 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
59900 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
59901 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
59902 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
59903 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
59904 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
59905 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
59906 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
59907 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
59908 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
59909 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
59910 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
59911 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
59912 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
59913 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
59914 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
59915 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
59916 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
59917 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
59918 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
59919 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
59920 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
59921 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
59922 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
59923 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
59924 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
59925 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
59926 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
59927 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
59928 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
59929 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
59930 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
59931 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
59932 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
59933 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
59934 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
59935 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
59936 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
59937 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
59938 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
59939 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
59940 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
59941 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
59942 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
59943 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
59944 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
59945 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
59946 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
59947 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
59948 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
59949 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
59950 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
59951 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
59952 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
59953 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
59954 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
59955 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
59956 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
59957 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
59958 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
59959 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
59960 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
59961 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
59962 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
59963 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
59964 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
59965 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
59966 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
59967 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
59968 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
59969 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
59970
59971 static swig_type_info *swig_type_initial[] = {
59972 &_swigt__p_buffer,
59973 &_swigt__p_char,
59974 &_swigt__p_form_ops_t,
59975 &_swigt__p_int,
59976 &_swigt__p_long,
59977 &_swigt__p_unsigned_char,
59978 &_swigt__p_unsigned_int,
59979 &_swigt__p_unsigned_long,
59980 &_swigt__p_wxANIHandler,
59981 &_swigt__p_wxAcceleratorEntry,
59982 &_swigt__p_wxAcceleratorTable,
59983 &_swigt__p_wxActivateEvent,
59984 &_swigt__p_wxAppTraits,
59985 &_swigt__p_wxArrayString,
59986 &_swigt__p_wxBMPHandler,
59987 &_swigt__p_wxBitmap,
59988 &_swigt__p_wxBoxSizer,
59989 &_swigt__p_wxButton,
59990 &_swigt__p_wxCURHandler,
59991 &_swigt__p_wxCaret,
59992 &_swigt__p_wxChildFocusEvent,
59993 &_swigt__p_wxClipboardTextEvent,
59994 &_swigt__p_wxCloseEvent,
59995 &_swigt__p_wxColour,
59996 &_swigt__p_wxCommandEvent,
59997 &_swigt__p_wxContextMenuEvent,
59998 &_swigt__p_wxControl,
59999 &_swigt__p_wxControlWithItems,
60000 &_swigt__p_wxCursor,
60001 &_swigt__p_wxDC,
60002 &_swigt__p_wxDateEvent,
60003 &_swigt__p_wxDateTime,
60004 &_swigt__p_wxDisplayChangedEvent,
60005 &_swigt__p_wxDouble,
60006 &_swigt__p_wxDropFilesEvent,
60007 &_swigt__p_wxDuplexMode,
60008 &_swigt__p_wxEraseEvent,
60009 &_swigt__p_wxEvent,
60010 &_swigt__p_wxEventBlocker,
60011 &_swigt__p_wxEventLoop,
60012 &_swigt__p_wxEventLoopActivator,
60013 &_swigt__p_wxEvtHandler,
60014 &_swigt__p_wxFSFile,
60015 &_swigt__p_wxFileSystem,
60016 &_swigt__p_wxFileSystemHandler,
60017 &_swigt__p_wxFlexGridSizer,
60018 &_swigt__p_wxFocusEvent,
60019 &_swigt__p_wxFont,
60020 &_swigt__p_wxFrame,
60021 &_swigt__p_wxGBPosition,
60022 &_swigt__p_wxGBSizerItem,
60023 &_swigt__p_wxGBSpan,
60024 &_swigt__p_wxGIFHandler,
60025 &_swigt__p_wxGridBagSizer,
60026 &_swigt__p_wxGridSizer,
60027 &_swigt__p_wxHelpEvent__Origin,
60028 &_swigt__p_wxICOHandler,
60029 &_swigt__p_wxIconizeEvent,
60030 &_swigt__p_wxIdleEvent,
60031 &_swigt__p_wxImage,
60032 &_swigt__p_wxImageHandler,
60033 &_swigt__p_wxImageHistogram,
60034 &_swigt__p_wxImage_HSVValue,
60035 &_swigt__p_wxImage_RGBValue,
60036 &_swigt__p_wxIndividualLayoutConstraint,
60037 &_swigt__p_wxInitDialogEvent,
60038 &_swigt__p_wxInputStream,
60039 &_swigt__p_wxInternetFSHandler,
60040 &_swigt__p_wxItemContainer,
60041 &_swigt__p_wxJPEGHandler,
60042 &_swigt__p_wxKeyEvent,
60043 &_swigt__p_wxLayoutConstraints,
60044 &_swigt__p_wxMaximizeEvent,
60045 &_swigt__p_wxMemoryFSHandler,
60046 &_swigt__p_wxMenu,
60047 &_swigt__p_wxMenuBar,
60048 &_swigt__p_wxMenuBarBase,
60049 &_swigt__p_wxMenuEvent,
60050 &_swigt__p_wxMenuItem,
60051 &_swigt__p_wxMouseCaptureChangedEvent,
60052 &_swigt__p_wxMouseCaptureLostEvent,
60053 &_swigt__p_wxMouseEvent,
60054 &_swigt__p_wxMoveEvent,
60055 &_swigt__p_wxNavigationKeyEvent,
60056 &_swigt__p_wxNcPaintEvent,
60057 &_swigt__p_wxNotifyEvent,
60058 &_swigt__p_wxObject,
60059 &_swigt__p_wxOutputStream,
60060 &_swigt__p_wxPCXHandler,
60061 &_swigt__p_wxPNGHandler,
60062 &_swigt__p_wxPNMHandler,
60063 &_swigt__p_wxPaintEvent,
60064 &_swigt__p_wxPaletteChangedEvent,
60065 &_swigt__p_wxPaperSize,
60066 &_swigt__p_wxPoint,
60067 &_swigt__p_wxPoint2D,
60068 &_swigt__p_wxPropagateOnce,
60069 &_swigt__p_wxPropagationDisabler,
60070 &_swigt__p_wxPyApp,
60071 &_swigt__p_wxPyCommandEvent,
60072 &_swigt__p_wxPyDropTarget,
60073 &_swigt__p_wxPyEvent,
60074 &_swigt__p_wxPyFileSystemHandler,
60075 &_swigt__p_wxPyImageHandler,
60076 &_swigt__p_wxPyInputStream,
60077 &_swigt__p_wxPySizer,
60078 &_swigt__p_wxPyValidator,
60079 &_swigt__p_wxQuantize,
60080 &_swigt__p_wxQueryNewPaletteEvent,
60081 &_swigt__p_wxRealPoint,
60082 &_swigt__p_wxRect,
60083 &_swigt__p_wxRect2D,
60084 &_swigt__p_wxRegion,
60085 &_swigt__p_wxScrollEvent,
60086 &_swigt__p_wxScrollWinEvent,
60087 &_swigt__p_wxSetCursorEvent,
60088 &_swigt__p_wxShowEvent,
60089 &_swigt__p_wxSize,
60090 &_swigt__p_wxSizeEvent,
60091 &_swigt__p_wxSizer,
60092 &_swigt__p_wxSizerFlags,
60093 &_swigt__p_wxSizerItem,
60094 &_swigt__p_wxStaticBox,
60095 &_swigt__p_wxStaticBoxSizer,
60096 &_swigt__p_wxStdDialogButtonSizer,
60097 &_swigt__p_wxSysColourChangedEvent,
60098 &_swigt__p_wxTGAHandler,
60099 &_swigt__p_wxTIFFHandler,
60100 &_swigt__p_wxToolTip,
60101 &_swigt__p_wxUpdateUIEvent,
60102 &_swigt__p_wxValidator,
60103 &_swigt__p_wxVisualAttributes,
60104 &_swigt__p_wxWindow,
60105 &_swigt__p_wxWindowCreateEvent,
60106 &_swigt__p_wxWindowDestroyEvent,
60107 &_swigt__p_wxXPMHandler,
60108 &_swigt__p_wxZipFSHandler,
60109 };
60110
60111 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60112 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60113 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60114 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60115 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60116 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60117 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60118 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60119 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60120 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60121 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60122 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60123 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60124 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60125 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}};
60126 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60127 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}};
60128 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60129 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}};
60130 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60131 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60132 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60133 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60134 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60135 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}};
60136 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60137 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}};
60138 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60139 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60140 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60141 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60142 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60143 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60144 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60145 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60146 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60147 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60148 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}};
60149 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60150 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60151 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60152 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
60153 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60154 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60155 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}};
60156 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}};
60157 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60158 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60159 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60160 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60161 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60162 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60163 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60164 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60165 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}};
60166 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60167 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}};
60168 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60169 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60170 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60171 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60172 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60173 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60174 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60175 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60176 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60177 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60178 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60179 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}};
60180 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60181 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60182 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60183 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60184 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60185 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60186 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60187 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60188 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60189 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60190 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60191 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60192 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60193 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60194 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60195 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60196 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60197 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
60198 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60199 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60200 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60201 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60202 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60203 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60204 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60205 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60206 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60207 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60208 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60209 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60210 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60211 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60212 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60213 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60214 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60215 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60216 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60217 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60218 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60219 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60220 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60221 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60222 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60223 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60224 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60225 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60226 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60227 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60228 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60229 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60230 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}};
60231 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60232 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}};
60233 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60234 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60235 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60236 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60237 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60238 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60239 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60240 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60241 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}};
60242 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60243 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}};
60244 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60245 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60246 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60247 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60248
60249 static swig_cast_info *swig_cast_initial[] = {
60250 _swigc__p_buffer,
60251 _swigc__p_char,
60252 _swigc__p_form_ops_t,
60253 _swigc__p_int,
60254 _swigc__p_long,
60255 _swigc__p_unsigned_char,
60256 _swigc__p_unsigned_int,
60257 _swigc__p_unsigned_long,
60258 _swigc__p_wxANIHandler,
60259 _swigc__p_wxAcceleratorEntry,
60260 _swigc__p_wxAcceleratorTable,
60261 _swigc__p_wxActivateEvent,
60262 _swigc__p_wxAppTraits,
60263 _swigc__p_wxArrayString,
60264 _swigc__p_wxBMPHandler,
60265 _swigc__p_wxBitmap,
60266 _swigc__p_wxBoxSizer,
60267 _swigc__p_wxButton,
60268 _swigc__p_wxCURHandler,
60269 _swigc__p_wxCaret,
60270 _swigc__p_wxChildFocusEvent,
60271 _swigc__p_wxClipboardTextEvent,
60272 _swigc__p_wxCloseEvent,
60273 _swigc__p_wxColour,
60274 _swigc__p_wxCommandEvent,
60275 _swigc__p_wxContextMenuEvent,
60276 _swigc__p_wxControl,
60277 _swigc__p_wxControlWithItems,
60278 _swigc__p_wxCursor,
60279 _swigc__p_wxDC,
60280 _swigc__p_wxDateEvent,
60281 _swigc__p_wxDateTime,
60282 _swigc__p_wxDisplayChangedEvent,
60283 _swigc__p_wxDouble,
60284 _swigc__p_wxDropFilesEvent,
60285 _swigc__p_wxDuplexMode,
60286 _swigc__p_wxEraseEvent,
60287 _swigc__p_wxEvent,
60288 _swigc__p_wxEventBlocker,
60289 _swigc__p_wxEventLoop,
60290 _swigc__p_wxEventLoopActivator,
60291 _swigc__p_wxEvtHandler,
60292 _swigc__p_wxFSFile,
60293 _swigc__p_wxFileSystem,
60294 _swigc__p_wxFileSystemHandler,
60295 _swigc__p_wxFlexGridSizer,
60296 _swigc__p_wxFocusEvent,
60297 _swigc__p_wxFont,
60298 _swigc__p_wxFrame,
60299 _swigc__p_wxGBPosition,
60300 _swigc__p_wxGBSizerItem,
60301 _swigc__p_wxGBSpan,
60302 _swigc__p_wxGIFHandler,
60303 _swigc__p_wxGridBagSizer,
60304 _swigc__p_wxGridSizer,
60305 _swigc__p_wxHelpEvent__Origin,
60306 _swigc__p_wxICOHandler,
60307 _swigc__p_wxIconizeEvent,
60308 _swigc__p_wxIdleEvent,
60309 _swigc__p_wxImage,
60310 _swigc__p_wxImageHandler,
60311 _swigc__p_wxImageHistogram,
60312 _swigc__p_wxImage_HSVValue,
60313 _swigc__p_wxImage_RGBValue,
60314 _swigc__p_wxIndividualLayoutConstraint,
60315 _swigc__p_wxInitDialogEvent,
60316 _swigc__p_wxInputStream,
60317 _swigc__p_wxInternetFSHandler,
60318 _swigc__p_wxItemContainer,
60319 _swigc__p_wxJPEGHandler,
60320 _swigc__p_wxKeyEvent,
60321 _swigc__p_wxLayoutConstraints,
60322 _swigc__p_wxMaximizeEvent,
60323 _swigc__p_wxMemoryFSHandler,
60324 _swigc__p_wxMenu,
60325 _swigc__p_wxMenuBar,
60326 _swigc__p_wxMenuBarBase,
60327 _swigc__p_wxMenuEvent,
60328 _swigc__p_wxMenuItem,
60329 _swigc__p_wxMouseCaptureChangedEvent,
60330 _swigc__p_wxMouseCaptureLostEvent,
60331 _swigc__p_wxMouseEvent,
60332 _swigc__p_wxMoveEvent,
60333 _swigc__p_wxNavigationKeyEvent,
60334 _swigc__p_wxNcPaintEvent,
60335 _swigc__p_wxNotifyEvent,
60336 _swigc__p_wxObject,
60337 _swigc__p_wxOutputStream,
60338 _swigc__p_wxPCXHandler,
60339 _swigc__p_wxPNGHandler,
60340 _swigc__p_wxPNMHandler,
60341 _swigc__p_wxPaintEvent,
60342 _swigc__p_wxPaletteChangedEvent,
60343 _swigc__p_wxPaperSize,
60344 _swigc__p_wxPoint,
60345 _swigc__p_wxPoint2D,
60346 _swigc__p_wxPropagateOnce,
60347 _swigc__p_wxPropagationDisabler,
60348 _swigc__p_wxPyApp,
60349 _swigc__p_wxPyCommandEvent,
60350 _swigc__p_wxPyDropTarget,
60351 _swigc__p_wxPyEvent,
60352 _swigc__p_wxPyFileSystemHandler,
60353 _swigc__p_wxPyImageHandler,
60354 _swigc__p_wxPyInputStream,
60355 _swigc__p_wxPySizer,
60356 _swigc__p_wxPyValidator,
60357 _swigc__p_wxQuantize,
60358 _swigc__p_wxQueryNewPaletteEvent,
60359 _swigc__p_wxRealPoint,
60360 _swigc__p_wxRect,
60361 _swigc__p_wxRect2D,
60362 _swigc__p_wxRegion,
60363 _swigc__p_wxScrollEvent,
60364 _swigc__p_wxScrollWinEvent,
60365 _swigc__p_wxSetCursorEvent,
60366 _swigc__p_wxShowEvent,
60367 _swigc__p_wxSize,
60368 _swigc__p_wxSizeEvent,
60369 _swigc__p_wxSizer,
60370 _swigc__p_wxSizerFlags,
60371 _swigc__p_wxSizerItem,
60372 _swigc__p_wxStaticBox,
60373 _swigc__p_wxStaticBoxSizer,
60374 _swigc__p_wxStdDialogButtonSizer,
60375 _swigc__p_wxSysColourChangedEvent,
60376 _swigc__p_wxTGAHandler,
60377 _swigc__p_wxTIFFHandler,
60378 _swigc__p_wxToolTip,
60379 _swigc__p_wxUpdateUIEvent,
60380 _swigc__p_wxValidator,
60381 _swigc__p_wxVisualAttributes,
60382 _swigc__p_wxWindow,
60383 _swigc__p_wxWindowCreateEvent,
60384 _swigc__p_wxWindowDestroyEvent,
60385 _swigc__p_wxXPMHandler,
60386 _swigc__p_wxZipFSHandler,
60387 };
60388
60389
60390 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
60391
60392 static swig_const_info swig_const_table[] = {
60393 {0, 0, 0, 0.0, 0, 0}};
60394
60395 #ifdef __cplusplus
60396 }
60397 #endif
60398 /* -----------------------------------------------------------------------------
60399 * Type initialization:
60400 * This problem is tough by the requirement that no dynamic
60401 * memory is used. Also, since swig_type_info structures store pointers to
60402 * swig_cast_info structures and swig_cast_info structures store pointers back
60403 * to swig_type_info structures, we need some lookup code at initialization.
60404 * The idea is that swig generates all the structures that are needed.
60405 * The runtime then collects these partially filled structures.
60406 * The SWIG_InitializeModule function takes these initial arrays out of
60407 * swig_module, and does all the lookup, filling in the swig_module.types
60408 * array with the correct data and linking the correct swig_cast_info
60409 * structures together.
60410 *
60411 * The generated swig_type_info structures are assigned staticly to an initial
60412 * array. We just loop though that array, and handle each type individually.
60413 * First we lookup if this type has been already loaded, and if so, use the
60414 * loaded structure instead of the generated one. Then we have to fill in the
60415 * cast linked list. The cast data is initially stored in something like a
60416 * two-dimensional array. Each row corresponds to a type (there are the same
60417 * number of rows as there are in the swig_type_initial array). Each entry in
60418 * a column is one of the swig_cast_info structures for that type.
60419 * The cast_initial array is actually an array of arrays, because each row has
60420 * a variable number of columns. So to actually build the cast linked list,
60421 * we find the array of casts associated with the type, and loop through it
60422 * adding the casts to the list. The one last trick we need to do is making
60423 * sure the type pointer in the swig_cast_info struct is correct.
60424 *
60425 * First off, we lookup the cast->type name to see if it is already loaded.
60426 * There are three cases to handle:
60427 * 1) If the cast->type has already been loaded AND the type we are adding
60428 * casting info to has not been loaded (it is in this module), THEN we
60429 * replace the cast->type pointer with the type pointer that has already
60430 * been loaded.
60431 * 2) If BOTH types (the one we are adding casting info to, and the
60432 * cast->type) are loaded, THEN the cast info has already been loaded by
60433 * the previous module so we just ignore it.
60434 * 3) Finally, if cast->type has not already been loaded, then we add that
60435 * swig_cast_info to the linked list (because the cast->type) pointer will
60436 * be correct.
60437 * ----------------------------------------------------------------------------- */
60438
60439 #ifdef __cplusplus
60440 extern "C" {
60441 #if 0
60442 } /* c-mode */
60443 #endif
60444 #endif
60445
60446 #if 0
60447 #define SWIGRUNTIME_DEBUG
60448 #endif
60449
60450 SWIGRUNTIME void
60451 SWIG_InitializeModule(void *clientdata) {
60452 size_t i;
60453 swig_module_info *module_head;
60454 static int init_run = 0;
60455
60456 clientdata = clientdata;
60457
60458 if (init_run) return;
60459 init_run = 1;
60460
60461 /* Initialize the swig_module */
60462 swig_module.type_initial = swig_type_initial;
60463 swig_module.cast_initial = swig_cast_initial;
60464
60465 /* Try and load any already created modules */
60466 module_head = SWIG_GetModule(clientdata);
60467 if (module_head) {
60468 swig_module.next = module_head->next;
60469 module_head->next = &swig_module;
60470 } else {
60471 /* This is the first module loaded */
60472 swig_module.next = &swig_module;
60473 SWIG_SetModule(clientdata, &swig_module);
60474 }
60475
60476 /* Now work on filling in swig_module.types */
60477 #ifdef SWIGRUNTIME_DEBUG
60478 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
60479 #endif
60480 for (i = 0; i < swig_module.size; ++i) {
60481 swig_type_info *type = 0;
60482 swig_type_info *ret;
60483 swig_cast_info *cast;
60484
60485 #ifdef SWIGRUNTIME_DEBUG
60486 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60487 #endif
60488
60489 /* if there is another module already loaded */
60490 if (swig_module.next != &swig_module) {
60491 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
60492 }
60493 if (type) {
60494 /* Overwrite clientdata field */
60495 #ifdef SWIGRUNTIME_DEBUG
60496 printf("SWIG_InitializeModule: found type %s\n", type->name);
60497 #endif
60498 if (swig_module.type_initial[i]->clientdata) {
60499 type->clientdata = swig_module.type_initial[i]->clientdata;
60500 #ifdef SWIGRUNTIME_DEBUG
60501 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
60502 #endif
60503 }
60504 } else {
60505 type = swig_module.type_initial[i];
60506 }
60507
60508 /* Insert casting types */
60509 cast = swig_module.cast_initial[i];
60510 while (cast->type) {
60511 /* Don't need to add information already in the list */
60512 ret = 0;
60513 #ifdef SWIGRUNTIME_DEBUG
60514 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
60515 #endif
60516 if (swig_module.next != &swig_module) {
60517 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
60518 #ifdef SWIGRUNTIME_DEBUG
60519 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
60520 #endif
60521 }
60522 if (ret) {
60523 if (type == swig_module.type_initial[i]) {
60524 #ifdef SWIGRUNTIME_DEBUG
60525 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
60526 #endif
60527 cast->type = ret;
60528 ret = 0;
60529 } else {
60530 /* Check for casting already in the list */
60531 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
60532 #ifdef SWIGRUNTIME_DEBUG
60533 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
60534 #endif
60535 if (!ocast) ret = 0;
60536 }
60537 }
60538
60539 if (!ret) {
60540 #ifdef SWIGRUNTIME_DEBUG
60541 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
60542 #endif
60543 if (type->cast) {
60544 type->cast->prev = cast;
60545 cast->next = type->cast;
60546 }
60547 type->cast = cast;
60548 }
60549 cast++;
60550 }
60551 /* Set entry in modules->types array equal to the type */
60552 swig_module.types[i] = type;
60553 }
60554 swig_module.types[i] = 0;
60555
60556 #ifdef SWIGRUNTIME_DEBUG
60557 printf("**** SWIG_InitializeModule: Cast List ******\n");
60558 for (i = 0; i < swig_module.size; ++i) {
60559 int j = 0;
60560 swig_cast_info *cast = swig_module.cast_initial[i];
60561 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60562 while (cast->type) {
60563 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
60564 cast++;
60565 ++j;
60566 }
60567 printf("---- Total casts: %d\n",j);
60568 }
60569 printf("**** SWIG_InitializeModule: Cast List ******\n");
60570 #endif
60571 }
60572
60573 /* This function will propagate the clientdata field of type to
60574 * any new swig_type_info structures that have been added into the list
60575 * of equivalent types. It is like calling
60576 * SWIG_TypeClientData(type, clientdata) a second time.
60577 */
60578 SWIGRUNTIME void
60579 SWIG_PropagateClientData(void) {
60580 size_t i;
60581 swig_cast_info *equiv;
60582 static int init_run = 0;
60583
60584 if (init_run) return;
60585 init_run = 1;
60586
60587 for (i = 0; i < swig_module.size; i++) {
60588 if (swig_module.types[i]->clientdata) {
60589 equiv = swig_module.types[i]->cast;
60590 while (equiv) {
60591 if (!equiv->converter) {
60592 if (equiv->type && !equiv->type->clientdata)
60593 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
60594 }
60595 equiv = equiv->next;
60596 }
60597 }
60598 }
60599 }
60600
60601 #ifdef __cplusplus
60602 #if 0
60603 {
60604 /* c-mode */
60605 #endif
60606 }
60607 #endif
60608
60609
60610
60611 #ifdef __cplusplus
60612 extern "C" {
60613 #endif
60614
60615 /* Python-specific SWIG API */
60616 #define SWIG_newvarlink() SWIG_Python_newvarlink()
60617 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
60618 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
60619
60620 /* -----------------------------------------------------------------------------
60621 * global variable support code.
60622 * ----------------------------------------------------------------------------- */
60623
60624 typedef struct swig_globalvar {
60625 char *name; /* Name of global variable */
60626 PyObject *(*get_attr)(void); /* Return the current value */
60627 int (*set_attr)(PyObject *); /* Set the value */
60628 struct swig_globalvar *next;
60629 } swig_globalvar;
60630
60631 typedef struct swig_varlinkobject {
60632 PyObject_HEAD
60633 swig_globalvar *vars;
60634 } swig_varlinkobject;
60635
60636 SWIGINTERN PyObject *
60637 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
60638 return PyString_FromString("<Swig global variables>");
60639 }
60640
60641 SWIGINTERN PyObject *
60642 swig_varlink_str(swig_varlinkobject *v) {
60643 PyObject *str = PyString_FromString("(");
60644 swig_globalvar *var;
60645 for (var = v->vars; var; var=var->next) {
60646 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
60647 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
60648 }
60649 PyString_ConcatAndDel(&str,PyString_FromString(")"));
60650 return str;
60651 }
60652
60653 SWIGINTERN int
60654 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
60655 PyObject *str = swig_varlink_str(v);
60656 fprintf(fp,"Swig global variables ");
60657 fprintf(fp,"%s\n", PyString_AsString(str));
60658 Py_DECREF(str);
60659 return 0;
60660 }
60661
60662 SWIGINTERN void
60663 swig_varlink_dealloc(swig_varlinkobject *v) {
60664 swig_globalvar *var = v->vars;
60665 while (var) {
60666 swig_globalvar *n = var->next;
60667 free(var->name);
60668 free(var);
60669 var = n;
60670 }
60671 }
60672
60673 SWIGINTERN PyObject *
60674 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
60675 PyObject *res = NULL;
60676 swig_globalvar *var = v->vars;
60677 while (var) {
60678 if (strcmp(var->name,n) == 0) {
60679 res = (*var->get_attr)();
60680 break;
60681 }
60682 var = var->next;
60683 }
60684 if (res == NULL && !PyErr_Occurred()) {
60685 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60686 }
60687 return res;
60688 }
60689
60690 SWIGINTERN int
60691 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
60692 int res = 1;
60693 swig_globalvar *var = v->vars;
60694 while (var) {
60695 if (strcmp(var->name,n) == 0) {
60696 res = (*var->set_attr)(p);
60697 break;
60698 }
60699 var = var->next;
60700 }
60701 if (res == 1 && !PyErr_Occurred()) {
60702 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60703 }
60704 return res;
60705 }
60706
60707 SWIGINTERN PyTypeObject*
60708 swig_varlink_type(void) {
60709 static char varlink__doc__[] = "Swig var link object";
60710 static PyTypeObject varlink_type;
60711 static int type_init = 0;
60712 if (!type_init) {
60713 const PyTypeObject tmp
60714 = {
60715 PyObject_HEAD_INIT(NULL)
60716 0, /* Number of items in variable part (ob_size) */
60717 (char *)"swigvarlink", /* Type name (tp_name) */
60718 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
60719 0, /* Itemsize (tp_itemsize) */
60720 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
60721 (printfunc) swig_varlink_print, /* Print (tp_print) */
60722 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
60723 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
60724 0, /* tp_compare */
60725 (reprfunc) swig_varlink_repr, /* tp_repr */
60726 0, /* tp_as_number */
60727 0, /* tp_as_sequence */
60728 0, /* tp_as_mapping */
60729 0, /* tp_hash */
60730 0, /* tp_call */
60731 (reprfunc)swig_varlink_str, /* tp_str */
60732 0, /* tp_getattro */
60733 0, /* tp_setattro */
60734 0, /* tp_as_buffer */
60735 0, /* tp_flags */
60736 varlink__doc__, /* tp_doc */
60737 0, /* tp_traverse */
60738 0, /* tp_clear */
60739 0, /* tp_richcompare */
60740 0, /* tp_weaklistoffset */
60741 #if PY_VERSION_HEX >= 0x02020000
60742 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
60743 #endif
60744 #if PY_VERSION_HEX >= 0x02030000
60745 0, /* tp_del */
60746 #endif
60747 #ifdef COUNT_ALLOCS
60748 0,0,0,0 /* tp_alloc -> tp_next */
60749 #endif
60750 };
60751 varlink_type = tmp;
60752 varlink_type.ob_type = &PyType_Type;
60753 type_init = 1;
60754 }
60755 return &varlink_type;
60756 }
60757
60758 /* Create a variable linking object for use later */
60759 SWIGINTERN PyObject *
60760 SWIG_Python_newvarlink(void) {
60761 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
60762 if (result) {
60763 result->vars = 0;
60764 }
60765 return ((PyObject*) result);
60766 }
60767
60768 SWIGINTERN void
60769 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
60770 swig_varlinkobject *v = (swig_varlinkobject *) p;
60771 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
60772 if (gv) {
60773 size_t size = strlen(name)+1;
60774 gv->name = (char *)malloc(size);
60775 if (gv->name) {
60776 strncpy(gv->name,name,size);
60777 gv->get_attr = get_attr;
60778 gv->set_attr = set_attr;
60779 gv->next = v->vars;
60780 }
60781 }
60782 v->vars = gv;
60783 }
60784
60785 SWIGINTERN PyObject *
60786 SWIG_globals() {
60787 static PyObject *_SWIG_globals = 0;
60788 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
60789 return _SWIG_globals;
60790 }
60791
60792 /* -----------------------------------------------------------------------------
60793 * constants/methods manipulation
60794 * ----------------------------------------------------------------------------- */
60795
60796 /* Install Constants */
60797 SWIGINTERN void
60798 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
60799 PyObject *obj = 0;
60800 size_t i;
60801 for (i = 0; constants[i].type; ++i) {
60802 switch(constants[i].type) {
60803 case SWIG_PY_POINTER:
60804 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
60805 break;
60806 case SWIG_PY_BINARY:
60807 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
60808 break;
60809 default:
60810 obj = 0;
60811 break;
60812 }
60813 if (obj) {
60814 PyDict_SetItemString(d, constants[i].name, obj);
60815 Py_DECREF(obj);
60816 }
60817 }
60818 }
60819
60820 /* -----------------------------------------------------------------------------*/
60821 /* Fix SwigMethods to carry the callback ptrs when needed */
60822 /* -----------------------------------------------------------------------------*/
60823
60824 SWIGINTERN void
60825 SWIG_Python_FixMethods(PyMethodDef *methods,
60826 swig_const_info *const_table,
60827 swig_type_info **types,
60828 swig_type_info **types_initial) {
60829 size_t i;
60830 for (i = 0; methods[i].ml_name; ++i) {
60831 const char *c = methods[i].ml_doc;
60832 if (c && (c = strstr(c, "swig_ptr: "))) {
60833 int j;
60834 swig_const_info *ci = 0;
60835 const char *name = c + 10;
60836 for (j = 0; const_table[j].type; ++j) {
60837 if (strncmp(const_table[j].name, name,
60838 strlen(const_table[j].name)) == 0) {
60839 ci = &(const_table[j]);
60840 break;
60841 }
60842 }
60843 if (ci) {
60844 size_t shift = (ci->ptype) - types;
60845 swig_type_info *ty = types_initial[shift];
60846 size_t ldoc = (c - methods[i].ml_doc);
60847 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
60848 char *ndoc = (char*)malloc(ldoc + lptr + 10);
60849 if (ndoc) {
60850 char *buff = ndoc;
60851 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
60852 if (ptr) {
60853 strncpy(buff, methods[i].ml_doc, ldoc);
60854 buff += ldoc;
60855 strncpy(buff, "swig_ptr: ", 10);
60856 buff += 10;
60857 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
60858 methods[i].ml_doc = ndoc;
60859 }
60860 }
60861 }
60862 }
60863 }
60864 }
60865
60866 #ifdef __cplusplus
60867 }
60868 #endif
60869
60870 /* -----------------------------------------------------------------------------*
60871 * Partial Init method
60872 * -----------------------------------------------------------------------------*/
60873
60874 #ifdef __cplusplus
60875 extern "C"
60876 #endif
60877 SWIGEXPORT void SWIG_init(void) {
60878 PyObject *m, *d;
60879
60880 /* Fix SwigMethods to carry the callback ptrs when needed */
60881 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
60882
60883 m = Py_InitModule((char *) SWIG_name, SwigMethods);
60884 d = PyModule_GetDict(m);
60885
60886 SWIG_InitializeModule(0);
60887 SWIG_InstallConstants(d,swig_const_table);
60888
60889
60890
60891 #ifndef wxPyUSE_EXPORT
60892 // Make our API structure a CObject so other modules can import it
60893 // from this module.
60894 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
60895 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
60896 Py_XDECREF(cobj);
60897 #endif
60898
60899 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
60900 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
60901 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
60902 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
60903 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
60904 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
60905 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
60906 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
60907 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
60908 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
60909 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
60910 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
60911 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
60912 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
60913 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
60914 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
60915 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
60916 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
60917 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
60918 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
60919 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
60920 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
60921 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
60922 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
60923 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
60924 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
60925 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
60926 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
60927 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
60928 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
60929 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
60930 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
60931 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
60932 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
60933 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
60934 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
60935 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
60936 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
60937 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
60938 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
60939 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
60940 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
60941 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
60942 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
60943 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
60944 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
60945 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
60946 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
60947 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
60948 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
60949 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
60950 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
60951 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
60952 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
60953 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
60954 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
60955 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
60956 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
60957 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
60958 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
60959 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
60960 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
60961 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
60962 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
60963 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
60964 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
60965 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
60966 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
60967 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
60968 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
60969 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
60970 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
60971 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
60972 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
60973 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
60974 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
60975 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
60976 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
60977 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
60978 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
60979 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
60980 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
60981 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
60982 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
60983 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
60984 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
60985 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
60986 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
60987 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
60988 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
60989 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
60990 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
60991 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
60992 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
60993 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
60994 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
60995 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
60996 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
60997 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
60998 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
60999 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61000 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61001 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61002 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61003 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61004 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61005 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61006 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61007 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61008 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61009 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61010 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61011 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61012 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61013 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61014 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61015 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61016 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61017 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61018 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61019 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61020 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61021 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61022 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61023 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61024 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61025 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61026 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61027 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61028 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61029 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61030 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61031 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61032 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61033 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61034 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61035 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61036 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61037 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61038 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61039 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61040 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61041 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61042 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61043 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61044 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61045 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61046 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61047 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61048 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61049 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61050 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61051 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61052 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61053 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61054 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61055 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61056 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61057 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61058 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61059 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61060 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61061 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61062 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61063 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61064 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61065 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61066 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61067 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61068 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61069 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61070 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61071 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61072 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61073 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61074 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61075 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61076 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61077 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61078 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61079 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61080 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61081 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61082 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61083 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61084 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61085 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61086 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61087 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61088 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61089 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61090 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61091 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61092 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61093 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61094 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61095 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61096 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61097 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61098 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61099 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61100 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61101 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61102 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61103 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61104 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61105 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61106 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61107 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61108 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61109 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61110 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61111 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61112 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61113 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61114 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61115 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61116 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61117 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61118 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61119 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61120 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61121 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61122 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61123 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61124 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61125 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61126 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61127 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61128 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61129 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61130 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61131 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61132 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61133 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61134 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61135 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61136 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61137 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61138 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61139 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61140 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61141 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61142 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61143 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61144 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61145 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61146 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61147 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61148 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61149 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61150 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61151 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61152 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61153 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61154 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61155 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61156 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61157 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61158 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61159 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61160 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61161 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61162 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61163 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61164 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61165 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61166 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61167 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61168 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61169 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61170 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61171 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61172 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61173 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61174 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61175 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61176 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61177 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61178 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61179 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61180 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61181 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61182 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61183 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61184 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61185 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61186 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61187 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61188 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61189 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61190 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61191 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61192 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61193 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61194 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61195 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61196 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61197 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61198 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61199 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61200 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61201 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61202 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61203 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61204 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61205 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61206 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61207 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61208 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61209 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61210 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61211 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61212 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61213 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61214 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61215 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61216 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61217 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61218 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61219 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61220 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61221 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61222 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61223 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61224 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61225 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61226 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61227 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61228 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61229 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61230 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61231 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61232 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61233 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61234 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61235 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61236 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61237 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61238 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61239 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61240 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61241 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61242 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61243 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61244 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61245 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61246 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61247 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61248 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61249 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61250 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61251 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61252 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61253 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61254 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61255 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61256 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61257 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61258 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61259 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61260 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61261 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61262 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61263 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61264 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61265 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61266 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61267 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61268 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61269 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61270 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61271 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61272 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61273 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61274 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61275 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61276 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61277 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61278 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61279 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61280 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61281 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61282 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61283 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61284 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61285 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61286 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61287 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61288 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61289 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61290 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61291 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61292 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61293 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61294 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61295 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61296 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61297 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61298 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61299 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61300 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61301 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61302 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61303 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61304 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61305 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61306 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61307 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61308 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61309 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61310 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61311 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61312 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61313 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61314 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61315 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61316 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61317 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61318 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61319 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61320 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61321 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61322 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61323 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61324 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61325 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61326 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
61327 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
61328 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
61329 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
61330 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
61331 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
61332 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
61333 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
61334 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
61335 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
61336 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
61337 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
61338 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
61339 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
61340 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
61341 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
61342 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
61343 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
61344 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
61345 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
61346 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
61347 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
61348 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
61349 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
61350 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
61351 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
61352 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
61353 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
61354 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
61355 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
61356 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
61357 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
61358 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
61359 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
61360 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
61361 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
61362 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
61363 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
61364 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
61365 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
61366 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
61367 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
61368 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
61369 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
61370 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
61371 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
61372 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
61373 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
61374 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
61375 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
61376 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
61377 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
61378 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
61379 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
61380 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
61381 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
61382 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
61383 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
61384 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
61385 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
61386 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
61387 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
61388 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
61389 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
61390 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
61391 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
61392 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
61393 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
61394 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
61395 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
61396 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
61397 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
61398 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
61399 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
61400 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
61401 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
61402 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
61403 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
61404 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
61405 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
61406 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
61407 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
61408 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
61409 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
61410 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
61411 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
61412 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
61413 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
61414 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
61415 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
61416 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
61417 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
61418 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
61419 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
61420 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
61421 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
61422 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
61423 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
61424 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
61425 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
61426 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
61427 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
61428 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
61429 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
61430 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
61431 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
61432 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
61433 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
61434 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
61435 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
61436 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
61437 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
61438 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
61439 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
61440 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
61441 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
61442 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
61443 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
61444 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
61445 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
61446 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
61447 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
61448 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
61449 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
61450 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
61451 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
61452 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
61453 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
61454 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
61455 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
61456 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
61457 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
61458 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
61459 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
61460 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
61461 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
61462 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
61463 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
61464 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
61465 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
61466 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
61467 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
61468 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
61469 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
61470 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
61471 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
61472 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
61473 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
61474 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
61475 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
61476 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
61477 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
61478 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
61479 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
61480 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
61481 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
61482 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
61483 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
61484 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
61485 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
61486 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
61487 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
61488 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
61489 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
61490 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
61491 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
61492 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
61493 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
61494 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
61495 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
61496 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
61497 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
61498 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
61499 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
61500 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
61501 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
61502 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
61503 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
61504 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
61505 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
61506 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
61507 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
61508 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
61509 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
61510 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
61511 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
61512 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
61513 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
61514 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
61515 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
61516 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
61517 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
61518 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
61519 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
61520 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
61521 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
61522 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
61523 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
61524 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
61525 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
61526 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
61527 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
61528 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
61529 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
61530 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
61531 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
61532 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
61533 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
61534 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
61535 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
61536 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
61537 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
61538 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
61539 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
61540 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
61541 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
61542 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
61543 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
61544 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
61545 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
61546 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
61547 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
61548 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
61549 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
61550 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
61551 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
61552 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
61553 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
61554 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
61555 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
61556 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
61557
61558 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
61559
61560
61561 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
61562
61563 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
61564 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
61565 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
61566 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
61567 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
61568 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
61569 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
61570 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
61571 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
61572 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
61573 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
61574 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
61575 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
61576 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
61577 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
61578 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
61579 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
61580 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
61581 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
61582 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
61583 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
61584 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
61585 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
61586 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
61587 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
61588 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
61589 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
61590 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
61591 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
61592 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
61593 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
61594 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
61595 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
61596 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
61597 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
61598 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
61599 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
61600 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
61601 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
61602 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
61603 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
61604 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
61605 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
61606 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
61607 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
61608 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
61609 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
61610 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
61611 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
61612 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
61613 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
61614 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
61615 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
61616 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
61617 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
61618 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
61619 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
61620 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
61621 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
61622 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
61623 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
61624 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
61625 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
61626 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
61627 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
61628 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
61629 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
61630 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
61631 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
61632 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
61633 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
61634 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
61635 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
61636 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
61637 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
61638 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
61639 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
61640 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
61641 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
61642 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
61643 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
61644 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
61645 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
61646 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
61647 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
61648 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
61649 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
61650 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
61651 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
61652 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
61653 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
61654 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
61655 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
61656 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
61657 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
61658 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
61659 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
61660 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
61661 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
61662 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
61663 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
61664 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
61665 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
61666 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
61667 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
61668 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
61669 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
61670 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
61671 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
61672 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
61673 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
61674 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
61675 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
61676 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
61677 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
61678 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
61679 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
61680 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
61681 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
61682 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
61683 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
61684 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
61685 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
61686 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
61687 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
61688 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
61689 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
61690 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
61691 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
61692 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
61693 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
61694 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
61695 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
61696 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
61697 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
61698 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
61699 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
61700 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
61701 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
61702 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
61703 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
61704 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
61705 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
61706 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
61707 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
61708 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
61709 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
61710 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
61711 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
61712 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
61713 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
61714 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
61715 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
61716 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
61717 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
61718 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
61719 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
61720 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
61721 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
61722 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
61723 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
61724 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
61725 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
61726 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
61727 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
61728 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
61729 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
61730 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
61731 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
61732 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
61733 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
61734 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
61735 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
61736 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
61737 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
61738 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
61739 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
61740 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
61741 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
61742 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
61743 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
61744 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
61745 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
61746 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
61747 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
61748 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
61749 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
61750 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
61751 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
61752 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
61753 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
61754 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
61755 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
61756 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
61757 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
61758 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
61759 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
61760 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
61761 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
61762 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
61763 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
61764 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
61765 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
61766 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
61767 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
61768 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
61769 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
61770 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
61771 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
61772 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
61773 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
61774 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
61775 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
61776 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
61777 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
61778
61779 // Initialize threading, some globals and such
61780 __wxPyPreStart(d);
61781
61782
61783 // Although these are defined in __version__ they need to be here too so
61784 // that an assert can be done to ensure that the wxPython and the wxWindows
61785 // versions match.
61786 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
61787 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
61788 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
61789
61790 }
61791
wxWidgets (Impactor)