]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
replaced run-time tests for wxRICHTEXT_USE_TOOLBOOK with compile-time ones to avoid...
[wxWidgets.git] / wxPython / src / gtk / _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 bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3893 #if wxUSE_HOTKEY
3894 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3895 #else
3896 return false;
3897 #endif
3898 }
3899 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3900
3901
3902
3903 return false;
3904
3905 }
3906 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3907 return wxPyGetWinHandle(self);
3908 }
3909 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3910 self->AssociateHandle((WXWidget)handle);
3911 }
3912 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3913
3914 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowById(id, parent);
3916 }
3917
3918 wxWindow* wxFindWindowByName( const wxString& name,
3919 const wxWindow *parent = NULL ) {
3920 return wxWindow::FindWindowByName(name, parent);
3921 }
3922
3923 wxWindow* wxFindWindowByLabel( const wxString& label,
3924 const wxWindow *parent = NULL ) {
3925 return wxWindow::FindWindowByLabel(label, parent);
3926 }
3927
3928
3929 #ifdef __WXMSW__
3930 #include <wx/msw/private.h> // to get wxGetWindowId
3931 #endif
3932
3933
3934 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3935 #ifdef __WXMSW__
3936 WXHWND hWnd = (WXHWND)_hWnd;
3937 long id = wxGetWindowId(hWnd);
3938 wxWindow* win = new wxWindow;
3939 if (parent)
3940 parent->AddChild(win);
3941 win->SetEventHandler(win);
3942 win->SetHWND(hWnd);
3943 win->SetId(id);
3944 win->SubclassWin(hWnd);
3945 win->AdoptAttributesFromHWND();
3946 win->SetupColours();
3947 return win;
3948 #else
3949 wxPyRaiseNotImplemented();
3950 return NULL;
3951 #endif
3952 }
3953
3954
3955 PyObject* GetTopLevelWindows() {
3956 return wxPy_ConvertList(&wxTopLevelWindows);
3957 }
3958
3959
3960 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3961 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3962 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3963
3964 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3965
3966
3967 SWIGINTERNINLINE int
3968 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3969 {
3970 unsigned long v;
3971 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3972 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3973 return res;
3974 }
3975
3976 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3977 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3978 wxMenuItemList& list = self->GetMenuItems();
3979 return wxPy_ConvertList(&list);
3980 }
3981 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3982 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3983 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3984 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3985 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3986 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3987 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3988 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3989 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3990 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3991 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3992 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3993 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3994 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3995 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3996 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3997 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3998 static const wxString wxPyControlNameStr(wxControlNameStr);
3999 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
4000 if (clientData) {
4001 wxPyClientData* data = new wxPyClientData(clientData);
4002 return self->Append(item, data);
4003 } else
4004 return self->Append(item);
4005 }
4006 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4007 if (clientData) {
4008 wxPyClientData* data = new wxPyClientData(clientData);
4009 return self->Insert(item, pos, data);
4010 } else
4011 return self->Insert(item, pos);
4012 }
4013 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4014 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4015 if (data) {
4016 Py_INCREF(data->m_obj);
4017 return data->m_obj;
4018 } else {
4019 Py_INCREF(Py_None);
4020 return Py_None;
4021 }
4022 }
4023 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4024 wxPyClientData* data = new wxPyClientData(clientData);
4025 self->SetClientObject(n, data);
4026 }
4027
4028
4029 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4030 if (borderInPixels == -1)
4031 return self->Border(direction);
4032 else
4033 return self->Border(direction, borderInPixels);
4034 }
4035 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4036 wxPyUserData* data = NULL;
4037 if ( userData ) {
4038 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4039 data = new wxPyUserData(userData);
4040 wxPyEndBlockThreads(blocked);
4041 }
4042 return new wxSizerItem(window, proportion, flag, border, data);
4043 }
4044 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4045 wxPyUserData* data = NULL;
4046 if ( userData ) {
4047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4048 data = new wxPyUserData(userData);
4049 wxPyEndBlockThreads(blocked);
4050 }
4051 return new wxSizerItem(width, height, proportion, flag, border, data);
4052 }
4053 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4054 wxPyUserData* data = NULL;
4055 if ( userData ) {
4056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4057 data = new wxPyUserData(userData);
4058 wxPyEndBlockThreads(blocked);
4059 }
4060 return new wxSizerItem(sizer, proportion, flag, border, data);
4061 }
4062
4063 SWIGINTERNINLINE PyObject *
4064 SWIG_From_float (float value)
4065 {
4066 return SWIG_From_double (value);
4067 }
4068
4069 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4070 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4071 if (data) {
4072 Py_INCREF(data->m_obj);
4073 return data->m_obj;
4074 } else {
4075 Py_INCREF(Py_None);
4076 return Py_None;
4077 }
4078 }
4079 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4080 wxPyUserData* data = NULL;
4081 if ( userData ) {
4082 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4083 data = new wxPyUserData(userData);
4084 wxPyEndBlockThreads(blocked);
4085 }
4086 self->SetUserData(data);
4087 }
4088
4089 // Figure out the type of the sizer item
4090
4091 struct wxPySizerItemInfo {
4092 wxPySizerItemInfo()
4093 : window(NULL), sizer(NULL), gotSize(false),
4094 size(wxDefaultSize), gotPos(false), pos(-1)
4095 {}
4096
4097 wxWindow* window;
4098 wxSizer* sizer;
4099 bool gotSize;
4100 wxSize size;
4101 bool gotPos;
4102 int pos;
4103 };
4104
4105 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4106
4107 wxPySizerItemInfo info;
4108 wxSize size;
4109 wxSize* sizePtr = &size;
4110
4111 // Find out what the type of the item is
4112 // try wxWindow
4113 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4114 PyErr_Clear();
4115 info.window = NULL;
4116
4117 // try wxSizer
4118 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4119 PyErr_Clear();
4120 info.sizer = NULL;
4121
4122 // try wxSize or (w,h)
4123 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4124 info.size = *sizePtr;
4125 info.gotSize = true;
4126 }
4127
4128 // or a single int
4129 if (checkIdx && PyInt_Check(item)) {
4130 info.pos = PyInt_AsLong(item);
4131 info.gotPos = true;
4132 }
4133 }
4134 }
4135
4136 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4137 // no expected type, figure out what kind of error message to generate
4138 if ( !checkSize && !checkIdx )
4139 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4140 else if ( checkSize && !checkIdx )
4141 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4142 else if ( !checkSize && checkIdx)
4143 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4144 else
4145 // can this one happen?
4146 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4147 }
4148
4149 return info;
4150 }
4151
4152 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4153 if (!self->GetClientObject())
4154 self->SetClientObject(new wxPyOORClientData(_self));
4155 }
4156 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4157
4158 wxPyUserData* data = NULL;
4159 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4160 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4161 if ( userData && (info.window || info.sizer || info.gotSize) )
4162 data = new wxPyUserData(userData);
4163 if ( info.sizer )
4164 PyObject_SetAttrString(item,"thisown",Py_False);
4165 wxPyEndBlockThreads(blocked);
4166
4167 // Now call the real Add method if a valid item type was found
4168 if ( info.window )
4169 return self->Add(info.window, proportion, flag, border, data);
4170 else if ( info.sizer )
4171 return self->Add(info.sizer, proportion, flag, border, data);
4172 else if (info.gotSize)
4173 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4174 proportion, flag, border, data);
4175 else
4176 return NULL;
4177 }
4178 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4179
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4182 if ( info.sizer )
4183 PyObject_SetAttrString(item,"thisown",Py_False);
4184 wxPyEndBlockThreads(blocked);
4185
4186 // Now call the real Add method if a valid item type was found
4187 if ( info.window )
4188 return self->Add(info.window, flags);
4189 else if ( info.sizer )
4190 return self->Add(info.sizer, flags);
4191 else if (info.gotSize)
4192 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4193 flags.GetProportion(),
4194 flags.GetFlags(),
4195 flags.GetBorderInPixels());
4196 else
4197 return NULL;
4198 }
4199 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4200
4201 wxPyUserData* data = NULL;
4202 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4203 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4204 if ( userData && (info.window || info.sizer || info.gotSize) )
4205 data = new wxPyUserData(userData);
4206 if ( info.sizer )
4207 PyObject_SetAttrString(item,"thisown",Py_False);
4208 wxPyEndBlockThreads(blocked);
4209
4210 // Now call the real Insert method if a valid item type was found
4211 if ( info.window )
4212 return self->Insert(before, info.window, proportion, flag, border, data);
4213 else if ( info.sizer )
4214 return self->Insert(before, info.sizer, proportion, flag, border, data);
4215 else if (info.gotSize)
4216 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4217 proportion, flag, border, data);
4218 else
4219 return NULL;
4220 }
4221 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4222
4223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4225 if ( info.sizer )
4226 PyObject_SetAttrString(item,"thisown",Py_False);
4227 wxPyEndBlockThreads(blocked);
4228
4229 // Now call the real Insert method if a valid item type was found
4230 if ( info.window )
4231 return self->Insert(before, info.window, flags);
4232 else if ( info.sizer )
4233 return self->Insert(before, info.sizer, flags);
4234 else if (info.gotSize)
4235 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4236 flags.GetProportion(),
4237 flags.GetFlags(),
4238 flags.GetBorderInPixels());
4239 else
4240 return NULL;
4241 }
4242 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4243
4244 wxPyUserData* data = NULL;
4245 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4246 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4247 if ( userData && (info.window || info.sizer || info.gotSize) )
4248 data = new wxPyUserData(userData);
4249 if ( info.sizer )
4250 PyObject_SetAttrString(item,"thisown",Py_False);
4251 wxPyEndBlockThreads(blocked);
4252
4253 // Now call the real Prepend method if a valid item type was found
4254 if ( info.window )
4255 return self->Prepend(info.window, proportion, flag, border, data);
4256 else if ( info.sizer )
4257 return self->Prepend(info.sizer, proportion, flag, border, data);
4258 else if (info.gotSize)
4259 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4260 proportion, flag, border, data);
4261 else
4262 return NULL;
4263 }
4264 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4265
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4268 if ( info.sizer )
4269 PyObject_SetAttrString(item,"thisown",Py_False);
4270 wxPyEndBlockThreads(blocked);
4271
4272 // Now call the real Add method if a valid item type was found
4273 if ( info.window )
4274 return self->Prepend(info.window, flags);
4275 else if ( info.sizer )
4276 return self->Prepend(info.sizer, flags);
4277 else if (info.gotSize)
4278 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4279 flags.GetProportion(),
4280 flags.GetFlags(),
4281 flags.GetBorderInPixels());
4282 else
4283 return NULL;
4284 }
4285 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4286 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4287 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4288 wxPyEndBlockThreads(blocked);
4289 if ( info.window )
4290 return false; //self->Remove(info.window);
4291 else if ( info.sizer )
4292 return self->Remove(info.sizer);
4293 else if ( info.gotPos )
4294 return self->Remove(info.pos);
4295 else
4296 return false;
4297 }
4298 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4300 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4301 wxPyEndBlockThreads(blocked);
4302 if ( info.window )
4303 return self->Detach(info.window);
4304 else if ( info.sizer )
4305 return self->Detach(info.sizer);
4306 else if ( info.gotPos )
4307 return self->Detach(info.pos);
4308 else
4309 return false;
4310 }
4311 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4314 wxPyEndBlockThreads(blocked);
4315 if ( info.window )
4316 return self->GetItem(info.window, recursive);
4317 else if ( info.sizer )
4318 return self->GetItem(info.sizer, recursive);
4319 else if ( info.gotPos )
4320 return self->GetItem(info.pos);
4321 else
4322 return NULL;
4323 }
4324 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4326 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4327 wxPyEndBlockThreads(blocked);
4328 if ( info.window )
4329 self->SetItemMinSize(info.window, size);
4330 else if ( info.sizer )
4331 self->SetItemMinSize(info.sizer, size);
4332 else if ( info.gotPos )
4333 self->SetItemMinSize(info.pos, size);
4334 }
4335 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4336 wxSizerItemList& list = self->GetChildren();
4337 return wxPy_ConvertList(&list);
4338 }
4339 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4342 wxPyEndBlockThreads(blocked);
4343 if ( info.window )
4344 return self->Show(info.window, show, recursive);
4345 else if ( info.sizer )
4346 return self->Show(info.sizer, show, recursive);
4347 else if ( info.gotPos )
4348 return self->Show(info.pos, show);
4349 else
4350 return false;
4351 }
4352 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4353 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4354 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4355 wxPyEndBlockThreads(blocked);
4356 if ( info.window )
4357 return self->IsShown(info.window);
4358 else if ( info.sizer )
4359 return self->IsShown(info.sizer);
4360 else if ( info.gotPos )
4361 return self->IsShown(info.pos);
4362 else
4363 return false;
4364 }
4365
4366 // See pyclasses.h
4367 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4368 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4369 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4370
4371
4372
4373
4374 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4375 {
4376 if (source == Py_None) {
4377 **obj = wxGBPosition(-1,-1);
4378 return true;
4379 }
4380 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4381 }
4382
4383 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4384 {
4385 if (source == Py_None) {
4386 **obj = wxGBSpan(-1,-1);
4387 return true;
4388 }
4389 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4390 }
4391
4392
4393 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4394 wxGBPosition temp, *obj = &temp;
4395 if ( other == Py_None ) return false;
4396 if ( ! wxGBPosition_helper(other, &obj) ) {
4397 PyErr_Clear();
4398 return false;
4399 }
4400 return self->operator==(*obj);
4401 }
4402 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4403 wxGBPosition temp, *obj = &temp;
4404 if ( other == Py_None ) return true;
4405 if ( ! wxGBPosition_helper(other, &obj)) {
4406 PyErr_Clear();
4407 return true;
4408 }
4409 return self->operator!=(*obj);
4410 }
4411 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4412 self->SetRow(row);
4413 self->SetCol(col);
4414 }
4415 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4416 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4417 PyObject* tup = PyTuple_New(2);
4418 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4419 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4420 wxPyEndBlockThreads(blocked);
4421 return tup;
4422 }
4423 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4424 wxGBSpan temp, *obj = &temp;
4425 if ( other == Py_None ) return false;
4426 if ( ! wxGBSpan_helper(other, &obj) ) {
4427 PyErr_Clear();
4428 return false;
4429 }
4430 return self->operator==(*obj);
4431 }
4432 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4433 wxGBSpan temp, *obj = &temp;
4434 if ( other == Py_None ) return true;
4435 if ( ! wxGBSpan_helper(other, &obj)) {
4436 PyErr_Clear();
4437 return true;
4438 }
4439 return self->operator!=(*obj);
4440 }
4441 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4442 self->SetRowspan(rowspan);
4443 self->SetColspan(colspan);
4444 }
4445 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4446 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4447 PyObject* tup = PyTuple_New(2);
4448 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4449 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4450 wxPyEndBlockThreads(blocked);
4451 return tup;
4452 }
4453 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4454 wxPyUserData* data = NULL;
4455 if ( userData ) {
4456 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4457 data = new wxPyUserData(userData);
4458 wxPyEndBlockThreads(blocked);
4459 }
4460 return new wxGBSizerItem(window, pos, span, flag, border, data);
4461 }
4462 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4463 wxPyUserData* data = NULL;
4464 if ( userData ) {
4465 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4466 data = new wxPyUserData(userData);
4467 wxPyEndBlockThreads(blocked);
4468 }
4469 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4470 }
4471 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4472 wxPyUserData* data = NULL;
4473 if ( userData ) {
4474 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4475 data = new wxPyUserData(userData);
4476 wxPyEndBlockThreads(blocked);
4477 }
4478 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4479 }
4480 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4481 int row, col;
4482 self->GetEndPos(row, col);
4483 return wxGBPosition(row, col);
4484 }
4485 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4486
4487 wxPyUserData* data = NULL;
4488 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4489 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4490 if ( userData && (info.window || info.sizer || info.gotSize) )
4491 data = new wxPyUserData(userData);
4492 if ( info.sizer )
4493 PyObject_SetAttrString(item,"thisown",Py_False);
4494 wxPyEndBlockThreads(blocked);
4495
4496 // Now call the real Add method if a valid item type was found
4497 if ( info.window )
4498 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4499 else if ( info.sizer )
4500 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4501 else if (info.gotSize)
4502 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4503 pos, span, flag, border, data);
4504 return NULL;
4505 }
4506
4507
4508 #ifdef __cplusplus
4509 extern "C" {
4510 #endif
4511 SWIGINTERN int EmptyString_set(PyObject *) {
4512 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4513 return 1;
4514 }
4515
4516
4517 SWIGINTERN PyObject *EmptyString_get(void) {
4518 PyObject *pyobj = 0;
4519
4520 {
4521 #if wxUSE_UNICODE
4522 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4523 #else
4524 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4525 #endif
4526 }
4527 return pyobj;
4528 }
4529
4530
4531 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4532 PyObject *resultobj = 0;
4533 wxObject *arg1 = (wxObject *) 0 ;
4534 wxString result;
4535 void *argp1 = 0 ;
4536 int res1 = 0 ;
4537 PyObject *swig_obj[1] ;
4538
4539 if (!args) SWIG_fail;
4540 swig_obj[0] = args;
4541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4542 if (!SWIG_IsOK(res1)) {
4543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4544 }
4545 arg1 = reinterpret_cast< wxObject * >(argp1);
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = wxObject_GetClassName(arg1);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 #if wxUSE_UNICODE
4554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4555 #else
4556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4557 #endif
4558 }
4559 return resultobj;
4560 fail:
4561 return NULL;
4562 }
4563
4564
4565 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4566 PyObject *resultobj = 0;
4567 wxObject *arg1 = (wxObject *) 0 ;
4568 void *argp1 = 0 ;
4569 int res1 = 0 ;
4570 PyObject *swig_obj[1] ;
4571
4572 if (!args) SWIG_fail;
4573 swig_obj[0] = args;
4574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4575 if (!SWIG_IsOK(res1)) {
4576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4577 }
4578 arg1 = reinterpret_cast< wxObject * >(argp1);
4579 {
4580 PyThreadState* __tstate = wxPyBeginAllowThreads();
4581 wxObject_Destroy(arg1);
4582 wxPyEndAllowThreads(__tstate);
4583 if (PyErr_Occurred()) SWIG_fail;
4584 }
4585 resultobj = SWIG_Py_Void();
4586 return resultobj;
4587 fail:
4588 return NULL;
4589 }
4590
4591
4592 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4593 PyObject *resultobj = 0;
4594 wxObject *arg1 = (wxObject *) 0 ;
4595 wxObject *arg2 = 0 ;
4596 bool result;
4597 void *argp1 = 0 ;
4598 int res1 = 0 ;
4599 void *argp2 = 0 ;
4600 int res2 = 0 ;
4601 PyObject * obj0 = 0 ;
4602 PyObject * obj1 = 0 ;
4603 char * kwnames[] = {
4604 (char *) "self",(char *) "p", NULL
4605 };
4606
4607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4609 if (!SWIG_IsOK(res1)) {
4610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4611 }
4612 arg1 = reinterpret_cast< wxObject * >(argp1);
4613 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4614 if (!SWIG_IsOK(res2)) {
4615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4616 }
4617 if (!argp2) {
4618 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4619 }
4620 arg2 = reinterpret_cast< wxObject * >(argp2);
4621 {
4622 PyThreadState* __tstate = wxPyBeginAllowThreads();
4623 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 {
4628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4629 }
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4637 PyObject *obj;
4638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4639 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4640 return SWIG_Py_Void();
4641 }
4642
4643 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4644 PyObject *resultobj = 0;
4645 wxSize *arg1 = (wxSize *) 0 ;
4646 int arg2 ;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 int val2 ;
4650 int ecode2 = 0 ;
4651 PyObject *swig_obj[2] ;
4652
4653 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4655 if (!SWIG_IsOK(res1)) {
4656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4657 }
4658 arg1 = reinterpret_cast< wxSize * >(argp1);
4659 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4660 if (!SWIG_IsOK(ecode2)) {
4661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4662 }
4663 arg2 = static_cast< int >(val2);
4664 if (arg1) (arg1)->x = arg2;
4665
4666 resultobj = SWIG_Py_Void();
4667 return resultobj;
4668 fail:
4669 return NULL;
4670 }
4671
4672
4673 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4674 PyObject *resultobj = 0;
4675 wxSize *arg1 = (wxSize *) 0 ;
4676 int result;
4677 void *argp1 = 0 ;
4678 int res1 = 0 ;
4679 PyObject *swig_obj[1] ;
4680
4681 if (!args) SWIG_fail;
4682 swig_obj[0] = args;
4683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4684 if (!SWIG_IsOK(res1)) {
4685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4686 }
4687 arg1 = reinterpret_cast< wxSize * >(argp1);
4688 result = (int) ((arg1)->x);
4689 resultobj = SWIG_From_int(static_cast< int >(result));
4690 return resultobj;
4691 fail:
4692 return NULL;
4693 }
4694
4695
4696 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4697 PyObject *resultobj = 0;
4698 wxSize *arg1 = (wxSize *) 0 ;
4699 int arg2 ;
4700 void *argp1 = 0 ;
4701 int res1 = 0 ;
4702 int val2 ;
4703 int ecode2 = 0 ;
4704 PyObject *swig_obj[2] ;
4705
4706 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4710 }
4711 arg1 = reinterpret_cast< wxSize * >(argp1);
4712 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4713 if (!SWIG_IsOK(ecode2)) {
4714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4715 }
4716 arg2 = static_cast< int >(val2);
4717 if (arg1) (arg1)->y = arg2;
4718
4719 resultobj = SWIG_Py_Void();
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 int result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 PyObject *swig_obj[1] ;
4733
4734 if (!args) SWIG_fail;
4735 swig_obj[0] = args;
4736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4737 if (!SWIG_IsOK(res1)) {
4738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4739 }
4740 arg1 = reinterpret_cast< wxSize * >(argp1);
4741 result = (int) ((arg1)->y);
4742 resultobj = SWIG_From_int(static_cast< int >(result));
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = 0;
4751 int arg1 = (int) 0 ;
4752 int arg2 = (int) 0 ;
4753 wxSize *result = 0 ;
4754 int val1 ;
4755 int ecode1 = 0 ;
4756 int val2 ;
4757 int ecode2 = 0 ;
4758 PyObject * obj0 = 0 ;
4759 PyObject * obj1 = 0 ;
4760 char * kwnames[] = {
4761 (char *) "w",(char *) "h", NULL
4762 };
4763
4764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4765 if (obj0) {
4766 ecode1 = SWIG_AsVal_int(obj0, &val1);
4767 if (!SWIG_IsOK(ecode1)) {
4768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4769 }
4770 arg1 = static_cast< int >(val1);
4771 }
4772 if (obj1) {
4773 ecode2 = SWIG_AsVal_int(obj1, &val2);
4774 if (!SWIG_IsOK(ecode2)) {
4775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4776 }
4777 arg2 = static_cast< int >(val2);
4778 }
4779 {
4780 result = (wxSize *)new wxSize(arg1,arg2);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4784 return resultobj;
4785 fail:
4786 return NULL;
4787 }
4788
4789
4790 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4791 PyObject *resultobj = 0;
4792 wxSize *arg1 = (wxSize *) 0 ;
4793 void *argp1 = 0 ;
4794 int res1 = 0 ;
4795 PyObject *swig_obj[1] ;
4796
4797 if (!args) SWIG_fail;
4798 swig_obj[0] = args;
4799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4800 if (!SWIG_IsOK(res1)) {
4801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4802 }
4803 arg1 = reinterpret_cast< wxSize * >(argp1);
4804 {
4805 delete arg1;
4806
4807 if (PyErr_Occurred()) SWIG_fail;
4808 }
4809 resultobj = SWIG_Py_Void();
4810 return resultobj;
4811 fail:
4812 return NULL;
4813 }
4814
4815
4816 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4817 PyObject *resultobj = 0;
4818 wxSize *arg1 = (wxSize *) 0 ;
4819 PyObject *arg2 = (PyObject *) 0 ;
4820 bool result;
4821 void *argp1 = 0 ;
4822 int res1 = 0 ;
4823 PyObject * obj0 = 0 ;
4824 PyObject * obj1 = 0 ;
4825 char * kwnames[] = {
4826 (char *) "self",(char *) "other", NULL
4827 };
4828
4829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4831 if (!SWIG_IsOK(res1)) {
4832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4833 }
4834 arg1 = reinterpret_cast< wxSize * >(argp1);
4835 arg2 = obj1;
4836 {
4837 result = (bool)wxSize___eq__(arg1,arg2);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 {
4841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4842 }
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 wxSize *arg1 = (wxSize *) 0 ;
4852 PyObject *arg2 = (PyObject *) 0 ;
4853 bool result;
4854 void *argp1 = 0 ;
4855 int res1 = 0 ;
4856 PyObject * obj0 = 0 ;
4857 PyObject * obj1 = 0 ;
4858 char * kwnames[] = {
4859 (char *) "self",(char *) "other", NULL
4860 };
4861
4862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4864 if (!SWIG_IsOK(res1)) {
4865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4866 }
4867 arg1 = reinterpret_cast< wxSize * >(argp1);
4868 arg2 = obj1;
4869 {
4870 result = (bool)wxSize___ne__(arg1,arg2);
4871 if (PyErr_Occurred()) SWIG_fail;
4872 }
4873 {
4874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4875 }
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = 0;
4884 wxSize *arg1 = (wxSize *) 0 ;
4885 wxSize *arg2 = 0 ;
4886 wxSize result;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 wxSize temp2 ;
4890 PyObject * obj0 = 0 ;
4891 PyObject * obj1 = 0 ;
4892 char * kwnames[] = {
4893 (char *) "self",(char *) "sz", NULL
4894 };
4895
4896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4898 if (!SWIG_IsOK(res1)) {
4899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4900 }
4901 arg1 = reinterpret_cast< wxSize * >(argp1);
4902 {
4903 arg2 = &temp2;
4904 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4905 }
4906 {
4907 result = (arg1)->operator +((wxSize const &)*arg2);
4908 if (PyErr_Occurred()) SWIG_fail;
4909 }
4910 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4911 return resultobj;
4912 fail:
4913 return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = 0;
4919 wxSize *arg1 = (wxSize *) 0 ;
4920 wxSize *arg2 = 0 ;
4921 wxSize result;
4922 void *argp1 = 0 ;
4923 int res1 = 0 ;
4924 wxSize temp2 ;
4925 PyObject * obj0 = 0 ;
4926 PyObject * obj1 = 0 ;
4927 char * kwnames[] = {
4928 (char *) "self",(char *) "sz", NULL
4929 };
4930
4931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4933 if (!SWIG_IsOK(res1)) {
4934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4935 }
4936 arg1 = reinterpret_cast< wxSize * >(argp1);
4937 {
4938 arg2 = &temp2;
4939 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4940 }
4941 {
4942 result = (arg1)->operator -((wxSize const &)*arg2);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4946 return resultobj;
4947 fail:
4948 return NULL;
4949 }
4950
4951
4952 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4953 PyObject *resultobj = 0;
4954 wxSize *arg1 = (wxSize *) 0 ;
4955 wxSize *arg2 = 0 ;
4956 void *argp1 = 0 ;
4957 int res1 = 0 ;
4958 wxSize temp2 ;
4959 PyObject * obj0 = 0 ;
4960 PyObject * obj1 = 0 ;
4961 char * kwnames[] = {
4962 (char *) "self",(char *) "sz", NULL
4963 };
4964
4965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4967 if (!SWIG_IsOK(res1)) {
4968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4969 }
4970 arg1 = reinterpret_cast< wxSize * >(argp1);
4971 {
4972 arg2 = &temp2;
4973 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4974 }
4975 {
4976 (arg1)->IncTo((wxSize const &)*arg2);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxSize *arg1 = (wxSize *) 0 ;
4989 wxSize *arg2 = 0 ;
4990 void *argp1 = 0 ;
4991 int res1 = 0 ;
4992 wxSize temp2 ;
4993 PyObject * obj0 = 0 ;
4994 PyObject * obj1 = 0 ;
4995 char * kwnames[] = {
4996 (char *) "self",(char *) "sz", NULL
4997 };
4998
4999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
5000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5001 if (!SWIG_IsOK(res1)) {
5002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5003 }
5004 arg1 = reinterpret_cast< wxSize * >(argp1);
5005 {
5006 arg2 = &temp2;
5007 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5008 }
5009 {
5010 (arg1)->DecTo((wxSize const &)*arg2);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 int arg2 ;
5024 int arg3 ;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 int val2 ;
5028 int ecode2 = 0 ;
5029 int val3 ;
5030 int ecode3 = 0 ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 PyObject * obj2 = 0 ;
5034 char * kwnames[] = {
5035 (char *) "self",(char *) "dx",(char *) "dy", NULL
5036 };
5037
5038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5040 if (!SWIG_IsOK(res1)) {
5041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5042 }
5043 arg1 = reinterpret_cast< wxSize * >(argp1);
5044 ecode2 = SWIG_AsVal_int(obj1, &val2);
5045 if (!SWIG_IsOK(ecode2)) {
5046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5047 }
5048 arg2 = static_cast< int >(val2);
5049 ecode3 = SWIG_AsVal_int(obj2, &val3);
5050 if (!SWIG_IsOK(ecode3)) {
5051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5052 }
5053 arg3 = static_cast< int >(val3);
5054 {
5055 (arg1)->IncBy(arg2,arg3);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 resultobj = SWIG_Py_Void();
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj = 0;
5067 wxSize *arg1 = (wxSize *) 0 ;
5068 int arg2 ;
5069 int arg3 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 int val2 ;
5073 int ecode2 = 0 ;
5074 int val3 ;
5075 int ecode3 = 0 ;
5076 PyObject * obj0 = 0 ;
5077 PyObject * obj1 = 0 ;
5078 PyObject * obj2 = 0 ;
5079 char * kwnames[] = {
5080 (char *) "self",(char *) "dx",(char *) "dy", NULL
5081 };
5082
5083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5087 }
5088 arg1 = reinterpret_cast< wxSize * >(argp1);
5089 ecode2 = SWIG_AsVal_int(obj1, &val2);
5090 if (!SWIG_IsOK(ecode2)) {
5091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5092 }
5093 arg2 = static_cast< int >(val2);
5094 ecode3 = SWIG_AsVal_int(obj2, &val3);
5095 if (!SWIG_IsOK(ecode3)) {
5096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5097 }
5098 arg3 = static_cast< int >(val3);
5099 {
5100 (arg1)->DecBy(arg2,arg3);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 resultobj = SWIG_Py_Void();
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 float arg2 ;
5114 float arg3 ;
5115 void *argp1 = 0 ;
5116 int res1 = 0 ;
5117 float val2 ;
5118 int ecode2 = 0 ;
5119 float val3 ;
5120 int ecode3 = 0 ;
5121 PyObject * obj0 = 0 ;
5122 PyObject * obj1 = 0 ;
5123 PyObject * obj2 = 0 ;
5124 char * kwnames[] = {
5125 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5126 };
5127
5128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5130 if (!SWIG_IsOK(res1)) {
5131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5132 }
5133 arg1 = reinterpret_cast< wxSize * >(argp1);
5134 ecode2 = SWIG_AsVal_float(obj1, &val2);
5135 if (!SWIG_IsOK(ecode2)) {
5136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5137 }
5138 arg2 = static_cast< float >(val2);
5139 ecode3 = SWIG_AsVal_float(obj2, &val3);
5140 if (!SWIG_IsOK(ecode3)) {
5141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5142 }
5143 arg3 = static_cast< float >(val3);
5144 {
5145 (arg1)->Scale(arg2,arg3);
5146 if (PyErr_Occurred()) SWIG_fail;
5147 }
5148 resultobj = SWIG_Py_Void();
5149 return resultobj;
5150 fail:
5151 return NULL;
5152 }
5153
5154
5155 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5156 PyObject *resultobj = 0;
5157 wxSize *arg1 = (wxSize *) 0 ;
5158 int arg2 ;
5159 int arg3 ;
5160 void *argp1 = 0 ;
5161 int res1 = 0 ;
5162 int val2 ;
5163 int ecode2 = 0 ;
5164 int val3 ;
5165 int ecode3 = 0 ;
5166 PyObject * obj0 = 0 ;
5167 PyObject * obj1 = 0 ;
5168 PyObject * obj2 = 0 ;
5169 char * kwnames[] = {
5170 (char *) "self",(char *) "w",(char *) "h", NULL
5171 };
5172
5173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5175 if (!SWIG_IsOK(res1)) {
5176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5177 }
5178 arg1 = reinterpret_cast< wxSize * >(argp1);
5179 ecode2 = SWIG_AsVal_int(obj1, &val2);
5180 if (!SWIG_IsOK(ecode2)) {
5181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5182 }
5183 arg2 = static_cast< int >(val2);
5184 ecode3 = SWIG_AsVal_int(obj2, &val3);
5185 if (!SWIG_IsOK(ecode3)) {
5186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5187 }
5188 arg3 = static_cast< int >(val3);
5189 {
5190 (arg1)->Set(arg2,arg3);
5191 if (PyErr_Occurred()) SWIG_fail;
5192 }
5193 resultobj = SWIG_Py_Void();
5194 return resultobj;
5195 fail:
5196 return NULL;
5197 }
5198
5199
5200 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5201 PyObject *resultobj = 0;
5202 wxSize *arg1 = (wxSize *) 0 ;
5203 int arg2 ;
5204 void *argp1 = 0 ;
5205 int res1 = 0 ;
5206 int val2 ;
5207 int ecode2 = 0 ;
5208 PyObject * obj0 = 0 ;
5209 PyObject * obj1 = 0 ;
5210 char * kwnames[] = {
5211 (char *) "self",(char *) "w", NULL
5212 };
5213
5214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5216 if (!SWIG_IsOK(res1)) {
5217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5218 }
5219 arg1 = reinterpret_cast< wxSize * >(argp1);
5220 ecode2 = SWIG_AsVal_int(obj1, &val2);
5221 if (!SWIG_IsOK(ecode2)) {
5222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5223 }
5224 arg2 = static_cast< int >(val2);
5225 {
5226 (arg1)->SetWidth(arg2);
5227 if (PyErr_Occurred()) SWIG_fail;
5228 }
5229 resultobj = SWIG_Py_Void();
5230 return resultobj;
5231 fail:
5232 return NULL;
5233 }
5234
5235
5236 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5237 PyObject *resultobj = 0;
5238 wxSize *arg1 = (wxSize *) 0 ;
5239 int arg2 ;
5240 void *argp1 = 0 ;
5241 int res1 = 0 ;
5242 int val2 ;
5243 int ecode2 = 0 ;
5244 PyObject * obj0 = 0 ;
5245 PyObject * obj1 = 0 ;
5246 char * kwnames[] = {
5247 (char *) "self",(char *) "h", NULL
5248 };
5249
5250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5252 if (!SWIG_IsOK(res1)) {
5253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5254 }
5255 arg1 = reinterpret_cast< wxSize * >(argp1);
5256 ecode2 = SWIG_AsVal_int(obj1, &val2);
5257 if (!SWIG_IsOK(ecode2)) {
5258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5259 }
5260 arg2 = static_cast< int >(val2);
5261 {
5262 (arg1)->SetHeight(arg2);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 resultobj = SWIG_Py_Void();
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5273 PyObject *resultobj = 0;
5274 wxSize *arg1 = (wxSize *) 0 ;
5275 int result;
5276 void *argp1 = 0 ;
5277 int res1 = 0 ;
5278 PyObject *swig_obj[1] ;
5279
5280 if (!args) SWIG_fail;
5281 swig_obj[0] = args;
5282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5283 if (!SWIG_IsOK(res1)) {
5284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5285 }
5286 arg1 = reinterpret_cast< wxSize * >(argp1);
5287 {
5288 result = (int)((wxSize const *)arg1)->GetWidth();
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 resultobj = SWIG_From_int(static_cast< int >(result));
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5299 PyObject *resultobj = 0;
5300 wxSize *arg1 = (wxSize *) 0 ;
5301 int result;
5302 void *argp1 = 0 ;
5303 int res1 = 0 ;
5304 PyObject *swig_obj[1] ;
5305
5306 if (!args) SWIG_fail;
5307 swig_obj[0] = args;
5308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5309 if (!SWIG_IsOK(res1)) {
5310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5311 }
5312 arg1 = reinterpret_cast< wxSize * >(argp1);
5313 {
5314 result = (int)((wxSize const *)arg1)->GetHeight();
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 resultobj = SWIG_From_int(static_cast< int >(result));
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5325 PyObject *resultobj = 0;
5326 wxSize *arg1 = (wxSize *) 0 ;
5327 bool result;
5328 void *argp1 = 0 ;
5329 int res1 = 0 ;
5330 PyObject *swig_obj[1] ;
5331
5332 if (!args) SWIG_fail;
5333 swig_obj[0] = args;
5334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5335 if (!SWIG_IsOK(res1)) {
5336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5337 }
5338 arg1 = reinterpret_cast< wxSize * >(argp1);
5339 {
5340 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5341 if (PyErr_Occurred()) SWIG_fail;
5342 }
5343 {
5344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5345 }
5346 return resultobj;
5347 fail:
5348 return NULL;
5349 }
5350
5351
5352 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5353 PyObject *resultobj = 0;
5354 wxSize *arg1 = (wxSize *) 0 ;
5355 wxSize *arg2 = 0 ;
5356 void *argp1 = 0 ;
5357 int res1 = 0 ;
5358 wxSize temp2 ;
5359 PyObject * obj0 = 0 ;
5360 PyObject * obj1 = 0 ;
5361 char * kwnames[] = {
5362 (char *) "self",(char *) "size", NULL
5363 };
5364
5365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5367 if (!SWIG_IsOK(res1)) {
5368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5369 }
5370 arg1 = reinterpret_cast< wxSize * >(argp1);
5371 {
5372 arg2 = &temp2;
5373 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5374 }
5375 {
5376 (arg1)->SetDefaults((wxSize const &)*arg2);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 resultobj = SWIG_Py_Void();
5380 return resultobj;
5381 fail:
5382 return NULL;
5383 }
5384
5385
5386 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5387 PyObject *resultobj = 0;
5388 wxSize *arg1 = (wxSize *) 0 ;
5389 PyObject *result = 0 ;
5390 void *argp1 = 0 ;
5391 int res1 = 0 ;
5392 PyObject *swig_obj[1] ;
5393
5394 if (!args) SWIG_fail;
5395 swig_obj[0] = args;
5396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5397 if (!SWIG_IsOK(res1)) {
5398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5399 }
5400 arg1 = reinterpret_cast< wxSize * >(argp1);
5401 {
5402 result = (PyObject *)wxSize_Get(arg1);
5403 if (PyErr_Occurred()) SWIG_fail;
5404 }
5405 resultobj = result;
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5413 PyObject *obj;
5414 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5415 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5416 return SWIG_Py_Void();
5417 }
5418
5419 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5420 return SWIG_Python_InitShadowInstance(args);
5421 }
5422
5423 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5424 PyObject *resultobj = 0;
5425 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5426 double arg2 ;
5427 void *argp1 = 0 ;
5428 int res1 = 0 ;
5429 double val2 ;
5430 int ecode2 = 0 ;
5431 PyObject *swig_obj[2] ;
5432
5433 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5435 if (!SWIG_IsOK(res1)) {
5436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5437 }
5438 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5439 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5440 if (!SWIG_IsOK(ecode2)) {
5441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5442 }
5443 arg2 = static_cast< double >(val2);
5444 if (arg1) (arg1)->x = arg2;
5445
5446 resultobj = SWIG_Py_Void();
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5454 PyObject *resultobj = 0;
5455 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5456 double result;
5457 void *argp1 = 0 ;
5458 int res1 = 0 ;
5459 PyObject *swig_obj[1] ;
5460
5461 if (!args) SWIG_fail;
5462 swig_obj[0] = args;
5463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5464 if (!SWIG_IsOK(res1)) {
5465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5466 }
5467 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5468 result = (double) ((arg1)->x);
5469 resultobj = SWIG_From_double(static_cast< double >(result));
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5479 double arg2 ;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 double val2 ;
5483 int ecode2 = 0 ;
5484 PyObject *swig_obj[2] ;
5485
5486 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5490 }
5491 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5492 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5493 if (!SWIG_IsOK(ecode2)) {
5494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5495 }
5496 arg2 = static_cast< double >(val2);
5497 if (arg1) (arg1)->y = arg2;
5498
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5507 PyObject *resultobj = 0;
5508 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5509 double result;
5510 void *argp1 = 0 ;
5511 int res1 = 0 ;
5512 PyObject *swig_obj[1] ;
5513
5514 if (!args) SWIG_fail;
5515 swig_obj[0] = args;
5516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5517 if (!SWIG_IsOK(res1)) {
5518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5519 }
5520 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5521 result = (double) ((arg1)->y);
5522 resultobj = SWIG_From_double(static_cast< double >(result));
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj = 0;
5531 double arg1 = (double) 0.0 ;
5532 double arg2 = (double) 0.0 ;
5533 wxRealPoint *result = 0 ;
5534 double val1 ;
5535 int ecode1 = 0 ;
5536 double val2 ;
5537 int ecode2 = 0 ;
5538 PyObject * obj0 = 0 ;
5539 PyObject * obj1 = 0 ;
5540 char * kwnames[] = {
5541 (char *) "x",(char *) "y", NULL
5542 };
5543
5544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5545 if (obj0) {
5546 ecode1 = SWIG_AsVal_double(obj0, &val1);
5547 if (!SWIG_IsOK(ecode1)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5549 }
5550 arg1 = static_cast< double >(val1);
5551 }
5552 if (obj1) {
5553 ecode2 = SWIG_AsVal_double(obj1, &val2);
5554 if (!SWIG_IsOK(ecode2)) {
5555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5556 }
5557 arg2 = static_cast< double >(val2);
5558 }
5559 {
5560 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5564 return resultobj;
5565 fail:
5566 return NULL;
5567 }
5568
5569
5570 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5571 PyObject *resultobj = 0;
5572 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5573 void *argp1 = 0 ;
5574 int res1 = 0 ;
5575 PyObject *swig_obj[1] ;
5576
5577 if (!args) SWIG_fail;
5578 swig_obj[0] = args;
5579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5580 if (!SWIG_IsOK(res1)) {
5581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5582 }
5583 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5584 {
5585 delete arg1;
5586
5587 if (PyErr_Occurred()) SWIG_fail;
5588 }
5589 resultobj = SWIG_Py_Void();
5590 return resultobj;
5591 fail:
5592 return NULL;
5593 }
5594
5595
5596 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5597 PyObject *resultobj = 0;
5598 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5599 PyObject *arg2 = (PyObject *) 0 ;
5600 bool result;
5601 void *argp1 = 0 ;
5602 int res1 = 0 ;
5603 PyObject * obj0 = 0 ;
5604 PyObject * obj1 = 0 ;
5605 char * kwnames[] = {
5606 (char *) "self",(char *) "other", NULL
5607 };
5608
5609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5611 if (!SWIG_IsOK(res1)) {
5612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5613 }
5614 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5615 arg2 = obj1;
5616 {
5617 result = (bool)wxRealPoint___eq__(arg1,arg2);
5618 if (PyErr_Occurred()) SWIG_fail;
5619 }
5620 {
5621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5622 }
5623 return resultobj;
5624 fail:
5625 return NULL;
5626 }
5627
5628
5629 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5630 PyObject *resultobj = 0;
5631 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5632 PyObject *arg2 = (PyObject *) 0 ;
5633 bool result;
5634 void *argp1 = 0 ;
5635 int res1 = 0 ;
5636 PyObject * obj0 = 0 ;
5637 PyObject * obj1 = 0 ;
5638 char * kwnames[] = {
5639 (char *) "self",(char *) "other", NULL
5640 };
5641
5642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5644 if (!SWIG_IsOK(res1)) {
5645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5646 }
5647 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5648 arg2 = obj1;
5649 {
5650 result = (bool)wxRealPoint___ne__(arg1,arg2);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 {
5654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5655 }
5656 return resultobj;
5657 fail:
5658 return NULL;
5659 }
5660
5661
5662 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5663 PyObject *resultobj = 0;
5664 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5665 wxRealPoint *arg2 = 0 ;
5666 wxRealPoint result;
5667 void *argp1 = 0 ;
5668 int res1 = 0 ;
5669 wxRealPoint temp2 ;
5670 PyObject * obj0 = 0 ;
5671 PyObject * obj1 = 0 ;
5672 char * kwnames[] = {
5673 (char *) "self",(char *) "pt", NULL
5674 };
5675
5676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5682 {
5683 arg2 = &temp2;
5684 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5685 }
5686 {
5687 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5688 if (PyErr_Occurred()) SWIG_fail;
5689 }
5690 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5691 return resultobj;
5692 fail:
5693 return NULL;
5694 }
5695
5696
5697 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5698 PyObject *resultobj = 0;
5699 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5700 wxRealPoint *arg2 = 0 ;
5701 wxRealPoint result;
5702 void *argp1 = 0 ;
5703 int res1 = 0 ;
5704 wxRealPoint temp2 ;
5705 PyObject * obj0 = 0 ;
5706 PyObject * obj1 = 0 ;
5707 char * kwnames[] = {
5708 (char *) "self",(char *) "pt", NULL
5709 };
5710
5711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5713 if (!SWIG_IsOK(res1)) {
5714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5715 }
5716 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5717 {
5718 arg2 = &temp2;
5719 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5720 }
5721 {
5722 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj = 0;
5734 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5735 double arg2 ;
5736 double arg3 ;
5737 void *argp1 = 0 ;
5738 int res1 = 0 ;
5739 double val2 ;
5740 int ecode2 = 0 ;
5741 double val3 ;
5742 int ecode3 = 0 ;
5743 PyObject * obj0 = 0 ;
5744 PyObject * obj1 = 0 ;
5745 PyObject * obj2 = 0 ;
5746 char * kwnames[] = {
5747 (char *) "self",(char *) "x",(char *) "y", NULL
5748 };
5749
5750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5756 ecode2 = SWIG_AsVal_double(obj1, &val2);
5757 if (!SWIG_IsOK(ecode2)) {
5758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5759 }
5760 arg2 = static_cast< double >(val2);
5761 ecode3 = SWIG_AsVal_double(obj2, &val3);
5762 if (!SWIG_IsOK(ecode3)) {
5763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5764 }
5765 arg3 = static_cast< double >(val3);
5766 {
5767 wxRealPoint_Set(arg1,arg2,arg3);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 resultobj = SWIG_Py_Void();
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5778 PyObject *resultobj = 0;
5779 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5780 PyObject *result = 0 ;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 PyObject *swig_obj[1] ;
5784
5785 if (!args) SWIG_fail;
5786 swig_obj[0] = args;
5787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5788 if (!SWIG_IsOK(res1)) {
5789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5790 }
5791 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5792 {
5793 result = (PyObject *)wxRealPoint_Get(arg1);
5794 if (PyErr_Occurred()) SWIG_fail;
5795 }
5796 resultobj = result;
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5804 PyObject *obj;
5805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5806 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5807 return SWIG_Py_Void();
5808 }
5809
5810 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5811 return SWIG_Python_InitShadowInstance(args);
5812 }
5813
5814 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5815 PyObject *resultobj = 0;
5816 wxPoint *arg1 = (wxPoint *) 0 ;
5817 int arg2 ;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 int val2 ;
5821 int ecode2 = 0 ;
5822 PyObject *swig_obj[2] ;
5823
5824 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5826 if (!SWIG_IsOK(res1)) {
5827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5828 }
5829 arg1 = reinterpret_cast< wxPoint * >(argp1);
5830 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5831 if (!SWIG_IsOK(ecode2)) {
5832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5833 }
5834 arg2 = static_cast< int >(val2);
5835 if (arg1) (arg1)->x = arg2;
5836
5837 resultobj = SWIG_Py_Void();
5838 return resultobj;
5839 fail:
5840 return NULL;
5841 }
5842
5843
5844 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5845 PyObject *resultobj = 0;
5846 wxPoint *arg1 = (wxPoint *) 0 ;
5847 int result;
5848 void *argp1 = 0 ;
5849 int res1 = 0 ;
5850 PyObject *swig_obj[1] ;
5851
5852 if (!args) SWIG_fail;
5853 swig_obj[0] = args;
5854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5855 if (!SWIG_IsOK(res1)) {
5856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5857 }
5858 arg1 = reinterpret_cast< wxPoint * >(argp1);
5859 result = (int) ((arg1)->x);
5860 resultobj = SWIG_From_int(static_cast< int >(result));
5861 return resultobj;
5862 fail:
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5868 PyObject *resultobj = 0;
5869 wxPoint *arg1 = (wxPoint *) 0 ;
5870 int arg2 ;
5871 void *argp1 = 0 ;
5872 int res1 = 0 ;
5873 int val2 ;
5874 int ecode2 = 0 ;
5875 PyObject *swig_obj[2] ;
5876
5877 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5879 if (!SWIG_IsOK(res1)) {
5880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5881 }
5882 arg1 = reinterpret_cast< wxPoint * >(argp1);
5883 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5884 if (!SWIG_IsOK(ecode2)) {
5885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5886 }
5887 arg2 = static_cast< int >(val2);
5888 if (arg1) (arg1)->y = arg2;
5889
5890 resultobj = SWIG_Py_Void();
5891 return resultobj;
5892 fail:
5893 return NULL;
5894 }
5895
5896
5897 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5898 PyObject *resultobj = 0;
5899 wxPoint *arg1 = (wxPoint *) 0 ;
5900 int result;
5901 void *argp1 = 0 ;
5902 int res1 = 0 ;
5903 PyObject *swig_obj[1] ;
5904
5905 if (!args) SWIG_fail;
5906 swig_obj[0] = args;
5907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5908 if (!SWIG_IsOK(res1)) {
5909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5910 }
5911 arg1 = reinterpret_cast< wxPoint * >(argp1);
5912 result = (int) ((arg1)->y);
5913 resultobj = SWIG_From_int(static_cast< int >(result));
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 int arg1 = (int) 0 ;
5923 int arg2 = (int) 0 ;
5924 wxPoint *result = 0 ;
5925 int val1 ;
5926 int ecode1 = 0 ;
5927 int val2 ;
5928 int ecode2 = 0 ;
5929 PyObject * obj0 = 0 ;
5930 PyObject * obj1 = 0 ;
5931 char * kwnames[] = {
5932 (char *) "x",(char *) "y", NULL
5933 };
5934
5935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5936 if (obj0) {
5937 ecode1 = SWIG_AsVal_int(obj0, &val1);
5938 if (!SWIG_IsOK(ecode1)) {
5939 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5940 }
5941 arg1 = static_cast< int >(val1);
5942 }
5943 if (obj1) {
5944 ecode2 = SWIG_AsVal_int(obj1, &val2);
5945 if (!SWIG_IsOK(ecode2)) {
5946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5947 }
5948 arg2 = static_cast< int >(val2);
5949 }
5950 {
5951 result = (wxPoint *)new wxPoint(arg1,arg2);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5955 return resultobj;
5956 fail:
5957 return NULL;
5958 }
5959
5960
5961 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5962 PyObject *resultobj = 0;
5963 wxPoint *arg1 = (wxPoint *) 0 ;
5964 void *argp1 = 0 ;
5965 int res1 = 0 ;
5966 PyObject *swig_obj[1] ;
5967
5968 if (!args) SWIG_fail;
5969 swig_obj[0] = args;
5970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5971 if (!SWIG_IsOK(res1)) {
5972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5973 }
5974 arg1 = reinterpret_cast< wxPoint * >(argp1);
5975 {
5976 delete arg1;
5977
5978 if (PyErr_Occurred()) SWIG_fail;
5979 }
5980 resultobj = SWIG_Py_Void();
5981 return resultobj;
5982 fail:
5983 return NULL;
5984 }
5985
5986
5987 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5988 PyObject *resultobj = 0;
5989 wxPoint *arg1 = (wxPoint *) 0 ;
5990 PyObject *arg2 = (PyObject *) 0 ;
5991 bool result;
5992 void *argp1 = 0 ;
5993 int res1 = 0 ;
5994 PyObject * obj0 = 0 ;
5995 PyObject * obj1 = 0 ;
5996 char * kwnames[] = {
5997 (char *) "self",(char *) "other", NULL
5998 };
5999
6000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6002 if (!SWIG_IsOK(res1)) {
6003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6004 }
6005 arg1 = reinterpret_cast< wxPoint * >(argp1);
6006 arg2 = obj1;
6007 {
6008 result = (bool)wxPoint___eq__(arg1,arg2);
6009 if (PyErr_Occurred()) SWIG_fail;
6010 }
6011 {
6012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6013 }
6014 return resultobj;
6015 fail:
6016 return NULL;
6017 }
6018
6019
6020 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6021 PyObject *resultobj = 0;
6022 wxPoint *arg1 = (wxPoint *) 0 ;
6023 PyObject *arg2 = (PyObject *) 0 ;
6024 bool result;
6025 void *argp1 = 0 ;
6026 int res1 = 0 ;
6027 PyObject * obj0 = 0 ;
6028 PyObject * obj1 = 0 ;
6029 char * kwnames[] = {
6030 (char *) "self",(char *) "other", NULL
6031 };
6032
6033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6035 if (!SWIG_IsOK(res1)) {
6036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6037 }
6038 arg1 = reinterpret_cast< wxPoint * >(argp1);
6039 arg2 = obj1;
6040 {
6041 result = (bool)wxPoint___ne__(arg1,arg2);
6042 if (PyErr_Occurred()) SWIG_fail;
6043 }
6044 {
6045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6046 }
6047 return resultobj;
6048 fail:
6049 return NULL;
6050 }
6051
6052
6053 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6054 PyObject *resultobj = 0;
6055 wxPoint *arg1 = (wxPoint *) 0 ;
6056 wxPoint *arg2 = 0 ;
6057 wxPoint result;
6058 void *argp1 = 0 ;
6059 int res1 = 0 ;
6060 wxPoint temp2 ;
6061 PyObject * obj0 = 0 ;
6062 PyObject * obj1 = 0 ;
6063 char * kwnames[] = {
6064 (char *) "self",(char *) "pt", NULL
6065 };
6066
6067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6069 if (!SWIG_IsOK(res1)) {
6070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6071 }
6072 arg1 = reinterpret_cast< wxPoint * >(argp1);
6073 {
6074 arg2 = &temp2;
6075 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6076 }
6077 {
6078 result = (arg1)->operator +((wxPoint const &)*arg2);
6079 if (PyErr_Occurred()) SWIG_fail;
6080 }
6081 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6082 return resultobj;
6083 fail:
6084 return NULL;
6085 }
6086
6087
6088 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6089 PyObject *resultobj = 0;
6090 wxPoint *arg1 = (wxPoint *) 0 ;
6091 wxPoint *arg2 = 0 ;
6092 wxPoint result;
6093 void *argp1 = 0 ;
6094 int res1 = 0 ;
6095 wxPoint temp2 ;
6096 PyObject * obj0 = 0 ;
6097 PyObject * obj1 = 0 ;
6098 char * kwnames[] = {
6099 (char *) "self",(char *) "pt", NULL
6100 };
6101
6102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6104 if (!SWIG_IsOK(res1)) {
6105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6106 }
6107 arg1 = reinterpret_cast< wxPoint * >(argp1);
6108 {
6109 arg2 = &temp2;
6110 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6111 }
6112 {
6113 result = (arg1)->operator -((wxPoint const &)*arg2);
6114 if (PyErr_Occurred()) SWIG_fail;
6115 }
6116 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6117 return resultobj;
6118 fail:
6119 return NULL;
6120 }
6121
6122
6123 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6124 PyObject *resultobj = 0;
6125 wxPoint *arg1 = (wxPoint *) 0 ;
6126 wxPoint *arg2 = 0 ;
6127 wxPoint *result = 0 ;
6128 void *argp1 = 0 ;
6129 int res1 = 0 ;
6130 wxPoint temp2 ;
6131 PyObject * obj0 = 0 ;
6132 PyObject * obj1 = 0 ;
6133 char * kwnames[] = {
6134 (char *) "self",(char *) "pt", NULL
6135 };
6136
6137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6139 if (!SWIG_IsOK(res1)) {
6140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6141 }
6142 arg1 = reinterpret_cast< wxPoint * >(argp1);
6143 {
6144 arg2 = &temp2;
6145 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6146 }
6147 {
6148 {
6149 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6150 result = (wxPoint *) &_result_ref;
6151 }
6152 if (PyErr_Occurred()) SWIG_fail;
6153 }
6154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6155 return resultobj;
6156 fail:
6157 return NULL;
6158 }
6159
6160
6161 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6162 PyObject *resultobj = 0;
6163 wxPoint *arg1 = (wxPoint *) 0 ;
6164 wxPoint *arg2 = 0 ;
6165 wxPoint *result = 0 ;
6166 void *argp1 = 0 ;
6167 int res1 = 0 ;
6168 wxPoint temp2 ;
6169 PyObject * obj0 = 0 ;
6170 PyObject * obj1 = 0 ;
6171 char * kwnames[] = {
6172 (char *) "self",(char *) "pt", NULL
6173 };
6174
6175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6177 if (!SWIG_IsOK(res1)) {
6178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6179 }
6180 arg1 = reinterpret_cast< wxPoint * >(argp1);
6181 {
6182 arg2 = &temp2;
6183 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6184 }
6185 {
6186 {
6187 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6188 result = (wxPoint *) &_result_ref;
6189 }
6190 if (PyErr_Occurred()) SWIG_fail;
6191 }
6192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6193 return resultobj;
6194 fail:
6195 return NULL;
6196 }
6197
6198
6199 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6200 PyObject *resultobj = 0;
6201 wxPoint *arg1 = (wxPoint *) 0 ;
6202 long arg2 ;
6203 long arg3 ;
6204 void *argp1 = 0 ;
6205 int res1 = 0 ;
6206 long val2 ;
6207 int ecode2 = 0 ;
6208 long val3 ;
6209 int ecode3 = 0 ;
6210 PyObject * obj0 = 0 ;
6211 PyObject * obj1 = 0 ;
6212 PyObject * obj2 = 0 ;
6213 char * kwnames[] = {
6214 (char *) "self",(char *) "x",(char *) "y", NULL
6215 };
6216
6217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6219 if (!SWIG_IsOK(res1)) {
6220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6221 }
6222 arg1 = reinterpret_cast< wxPoint * >(argp1);
6223 ecode2 = SWIG_AsVal_long(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6226 }
6227 arg2 = static_cast< long >(val2);
6228 ecode3 = SWIG_AsVal_long(obj2, &val3);
6229 if (!SWIG_IsOK(ecode3)) {
6230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6231 }
6232 arg3 = static_cast< long >(val3);
6233 {
6234 wxPoint_Set(arg1,arg2,arg3);
6235 if (PyErr_Occurred()) SWIG_fail;
6236 }
6237 resultobj = SWIG_Py_Void();
6238 return resultobj;
6239 fail:
6240 return NULL;
6241 }
6242
6243
6244 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6245 PyObject *resultobj = 0;
6246 wxPoint *arg1 = (wxPoint *) 0 ;
6247 PyObject *result = 0 ;
6248 void *argp1 = 0 ;
6249 int res1 = 0 ;
6250 PyObject *swig_obj[1] ;
6251
6252 if (!args) SWIG_fail;
6253 swig_obj[0] = args;
6254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6255 if (!SWIG_IsOK(res1)) {
6256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6257 }
6258 arg1 = reinterpret_cast< wxPoint * >(argp1);
6259 {
6260 result = (PyObject *)wxPoint_Get(arg1);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = result;
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6271 PyObject *obj;
6272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6273 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6274 return SWIG_Py_Void();
6275 }
6276
6277 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 return SWIG_Python_InitShadowInstance(args);
6279 }
6280
6281 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj = 0;
6283 int arg1 = (int) 0 ;
6284 int arg2 = (int) 0 ;
6285 int arg3 = (int) 0 ;
6286 int arg4 = (int) 0 ;
6287 wxRect *result = 0 ;
6288 int val1 ;
6289 int ecode1 = 0 ;
6290 int val2 ;
6291 int ecode2 = 0 ;
6292 int val3 ;
6293 int ecode3 = 0 ;
6294 int val4 ;
6295 int ecode4 = 0 ;
6296 PyObject * obj0 = 0 ;
6297 PyObject * obj1 = 0 ;
6298 PyObject * obj2 = 0 ;
6299 PyObject * obj3 = 0 ;
6300 char * kwnames[] = {
6301 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6302 };
6303
6304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6305 if (obj0) {
6306 ecode1 = SWIG_AsVal_int(obj0, &val1);
6307 if (!SWIG_IsOK(ecode1)) {
6308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6309 }
6310 arg1 = static_cast< int >(val1);
6311 }
6312 if (obj1) {
6313 ecode2 = SWIG_AsVal_int(obj1, &val2);
6314 if (!SWIG_IsOK(ecode2)) {
6315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6316 }
6317 arg2 = static_cast< int >(val2);
6318 }
6319 if (obj2) {
6320 ecode3 = SWIG_AsVal_int(obj2, &val3);
6321 if (!SWIG_IsOK(ecode3)) {
6322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6323 }
6324 arg3 = static_cast< int >(val3);
6325 }
6326 if (obj3) {
6327 ecode4 = SWIG_AsVal_int(obj3, &val4);
6328 if (!SWIG_IsOK(ecode4)) {
6329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6330 }
6331 arg4 = static_cast< int >(val4);
6332 }
6333 {
6334 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6345 PyObject *resultobj = 0;
6346 wxPoint *arg1 = 0 ;
6347 wxPoint *arg2 = 0 ;
6348 wxRect *result = 0 ;
6349 wxPoint temp1 ;
6350 wxPoint temp2 ;
6351 PyObject * obj0 = 0 ;
6352 PyObject * obj1 = 0 ;
6353 char * kwnames[] = {
6354 (char *) "topLeft",(char *) "bottomRight", NULL
6355 };
6356
6357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6358 {
6359 arg1 = &temp1;
6360 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6361 }
6362 {
6363 arg2 = &temp2;
6364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6365 }
6366 {
6367 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6368 if (PyErr_Occurred()) SWIG_fail;
6369 }
6370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6371 return resultobj;
6372 fail:
6373 return NULL;
6374 }
6375
6376
6377 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6378 PyObject *resultobj = 0;
6379 wxPoint *arg1 = 0 ;
6380 wxSize *arg2 = 0 ;
6381 wxRect *result = 0 ;
6382 wxPoint temp1 ;
6383 wxSize temp2 ;
6384 PyObject * obj0 = 0 ;
6385 PyObject * obj1 = 0 ;
6386 char * kwnames[] = {
6387 (char *) "pos",(char *) "size", NULL
6388 };
6389
6390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6391 {
6392 arg1 = &temp1;
6393 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6394 }
6395 {
6396 arg2 = &temp2;
6397 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6398 }
6399 {
6400 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj = 0;
6412 wxSize *arg1 = 0 ;
6413 wxRect *result = 0 ;
6414 wxSize temp1 ;
6415 PyObject * obj0 = 0 ;
6416 char * kwnames[] = {
6417 (char *) "size", NULL
6418 };
6419
6420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6421 {
6422 arg1 = &temp1;
6423 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6424 }
6425 {
6426 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6437 PyObject *resultobj = 0;
6438 wxRect *arg1 = (wxRect *) 0 ;
6439 void *argp1 = 0 ;
6440 int res1 = 0 ;
6441 PyObject *swig_obj[1] ;
6442
6443 if (!args) SWIG_fail;
6444 swig_obj[0] = args;
6445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6446 if (!SWIG_IsOK(res1)) {
6447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6448 }
6449 arg1 = reinterpret_cast< wxRect * >(argp1);
6450 {
6451 delete arg1;
6452
6453 if (PyErr_Occurred()) SWIG_fail;
6454 }
6455 resultobj = SWIG_Py_Void();
6456 return resultobj;
6457 fail:
6458 return NULL;
6459 }
6460
6461
6462 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6463 PyObject *resultobj = 0;
6464 wxRect *arg1 = (wxRect *) 0 ;
6465 int result;
6466 void *argp1 = 0 ;
6467 int res1 = 0 ;
6468 PyObject *swig_obj[1] ;
6469
6470 if (!args) SWIG_fail;
6471 swig_obj[0] = args;
6472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6473 if (!SWIG_IsOK(res1)) {
6474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6475 }
6476 arg1 = reinterpret_cast< wxRect * >(argp1);
6477 {
6478 result = (int)((wxRect const *)arg1)->GetX();
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_From_int(static_cast< int >(result));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj = 0;
6490 wxRect *arg1 = (wxRect *) 0 ;
6491 int arg2 ;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 int val2 ;
6495 int ecode2 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "x", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 ecode2 = SWIG_AsVal_int(obj1, &val2);
6509 if (!SWIG_IsOK(ecode2)) {
6510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6511 }
6512 arg2 = static_cast< int >(val2);
6513 {
6514 (arg1)->SetX(arg2);
6515 if (PyErr_Occurred()) SWIG_fail;
6516 }
6517 resultobj = SWIG_Py_Void();
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6525 PyObject *resultobj = 0;
6526 wxRect *arg1 = (wxRect *) 0 ;
6527 int result;
6528 void *argp1 = 0 ;
6529 int res1 = 0 ;
6530 PyObject *swig_obj[1] ;
6531
6532 if (!args) SWIG_fail;
6533 swig_obj[0] = args;
6534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6535 if (!SWIG_IsOK(res1)) {
6536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6537 }
6538 arg1 = reinterpret_cast< wxRect * >(argp1);
6539 {
6540 result = (int)(arg1)->GetY();
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 resultobj = SWIG_From_int(static_cast< int >(result));
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6551 PyObject *resultobj = 0;
6552 wxRect *arg1 = (wxRect *) 0 ;
6553 int arg2 ;
6554 void *argp1 = 0 ;
6555 int res1 = 0 ;
6556 int val2 ;
6557 int ecode2 = 0 ;
6558 PyObject * obj0 = 0 ;
6559 PyObject * obj1 = 0 ;
6560 char * kwnames[] = {
6561 (char *) "self",(char *) "y", NULL
6562 };
6563
6564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6566 if (!SWIG_IsOK(res1)) {
6567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6568 }
6569 arg1 = reinterpret_cast< wxRect * >(argp1);
6570 ecode2 = SWIG_AsVal_int(obj1, &val2);
6571 if (!SWIG_IsOK(ecode2)) {
6572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6573 }
6574 arg2 = static_cast< int >(val2);
6575 {
6576 (arg1)->SetY(arg2);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 resultobj = SWIG_Py_Void();
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6587 PyObject *resultobj = 0;
6588 wxRect *arg1 = (wxRect *) 0 ;
6589 int result;
6590 void *argp1 = 0 ;
6591 int res1 = 0 ;
6592 PyObject *swig_obj[1] ;
6593
6594 if (!args) SWIG_fail;
6595 swig_obj[0] = args;
6596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6597 if (!SWIG_IsOK(res1)) {
6598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6599 }
6600 arg1 = reinterpret_cast< wxRect * >(argp1);
6601 {
6602 result = (int)((wxRect const *)arg1)->GetWidth();
6603 if (PyErr_Occurred()) SWIG_fail;
6604 }
6605 resultobj = SWIG_From_int(static_cast< int >(result));
6606 return resultobj;
6607 fail:
6608 return NULL;
6609 }
6610
6611
6612 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6613 PyObject *resultobj = 0;
6614 wxRect *arg1 = (wxRect *) 0 ;
6615 int arg2 ;
6616 void *argp1 = 0 ;
6617 int res1 = 0 ;
6618 int val2 ;
6619 int ecode2 = 0 ;
6620 PyObject * obj0 = 0 ;
6621 PyObject * obj1 = 0 ;
6622 char * kwnames[] = {
6623 (char *) "self",(char *) "w", NULL
6624 };
6625
6626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6628 if (!SWIG_IsOK(res1)) {
6629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6630 }
6631 arg1 = reinterpret_cast< wxRect * >(argp1);
6632 ecode2 = SWIG_AsVal_int(obj1, &val2);
6633 if (!SWIG_IsOK(ecode2)) {
6634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6635 }
6636 arg2 = static_cast< int >(val2);
6637 {
6638 (arg1)->SetWidth(arg2);
6639 if (PyErr_Occurred()) SWIG_fail;
6640 }
6641 resultobj = SWIG_Py_Void();
6642 return resultobj;
6643 fail:
6644 return NULL;
6645 }
6646
6647
6648 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6649 PyObject *resultobj = 0;
6650 wxRect *arg1 = (wxRect *) 0 ;
6651 int result;
6652 void *argp1 = 0 ;
6653 int res1 = 0 ;
6654 PyObject *swig_obj[1] ;
6655
6656 if (!args) SWIG_fail;
6657 swig_obj[0] = args;
6658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6659 if (!SWIG_IsOK(res1)) {
6660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6661 }
6662 arg1 = reinterpret_cast< wxRect * >(argp1);
6663 {
6664 result = (int)((wxRect const *)arg1)->GetHeight();
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 resultobj = SWIG_From_int(static_cast< int >(result));
6668 return resultobj;
6669 fail:
6670 return NULL;
6671 }
6672
6673
6674 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6675 PyObject *resultobj = 0;
6676 wxRect *arg1 = (wxRect *) 0 ;
6677 int arg2 ;
6678 void *argp1 = 0 ;
6679 int res1 = 0 ;
6680 int val2 ;
6681 int ecode2 = 0 ;
6682 PyObject * obj0 = 0 ;
6683 PyObject * obj1 = 0 ;
6684 char * kwnames[] = {
6685 (char *) "self",(char *) "h", NULL
6686 };
6687
6688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6690 if (!SWIG_IsOK(res1)) {
6691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6692 }
6693 arg1 = reinterpret_cast< wxRect * >(argp1);
6694 ecode2 = SWIG_AsVal_int(obj1, &val2);
6695 if (!SWIG_IsOK(ecode2)) {
6696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6697 }
6698 arg2 = static_cast< int >(val2);
6699 {
6700 (arg1)->SetHeight(arg2);
6701 if (PyErr_Occurred()) SWIG_fail;
6702 }
6703 resultobj = SWIG_Py_Void();
6704 return resultobj;
6705 fail:
6706 return NULL;
6707 }
6708
6709
6710 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6711 PyObject *resultobj = 0;
6712 wxRect *arg1 = (wxRect *) 0 ;
6713 wxPoint result;
6714 void *argp1 = 0 ;
6715 int res1 = 0 ;
6716 PyObject *swig_obj[1] ;
6717
6718 if (!args) SWIG_fail;
6719 swig_obj[0] = args;
6720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6721 if (!SWIG_IsOK(res1)) {
6722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6723 }
6724 arg1 = reinterpret_cast< wxRect * >(argp1);
6725 {
6726 result = ((wxRect const *)arg1)->GetPosition();
6727 if (PyErr_Occurred()) SWIG_fail;
6728 }
6729 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6730 return resultobj;
6731 fail:
6732 return NULL;
6733 }
6734
6735
6736 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6737 PyObject *resultobj = 0;
6738 wxRect *arg1 = (wxRect *) 0 ;
6739 wxPoint *arg2 = 0 ;
6740 void *argp1 = 0 ;
6741 int res1 = 0 ;
6742 wxPoint temp2 ;
6743 PyObject * obj0 = 0 ;
6744 PyObject * obj1 = 0 ;
6745 char * kwnames[] = {
6746 (char *) "self",(char *) "p", NULL
6747 };
6748
6749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6751 if (!SWIG_IsOK(res1)) {
6752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6753 }
6754 arg1 = reinterpret_cast< wxRect * >(argp1);
6755 {
6756 arg2 = &temp2;
6757 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6758 }
6759 {
6760 (arg1)->SetPosition((wxPoint const &)*arg2);
6761 if (PyErr_Occurred()) SWIG_fail;
6762 }
6763 resultobj = SWIG_Py_Void();
6764 return resultobj;
6765 fail:
6766 return NULL;
6767 }
6768
6769
6770 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6771 PyObject *resultobj = 0;
6772 wxRect *arg1 = (wxRect *) 0 ;
6773 wxSize result;
6774 void *argp1 = 0 ;
6775 int res1 = 0 ;
6776 PyObject *swig_obj[1] ;
6777
6778 if (!args) SWIG_fail;
6779 swig_obj[0] = args;
6780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6781 if (!SWIG_IsOK(res1)) {
6782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6783 }
6784 arg1 = reinterpret_cast< wxRect * >(argp1);
6785 {
6786 result = ((wxRect const *)arg1)->GetSize();
6787 if (PyErr_Occurred()) SWIG_fail;
6788 }
6789 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6790 return resultobj;
6791 fail:
6792 return NULL;
6793 }
6794
6795
6796 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6797 PyObject *resultobj = 0;
6798 wxRect *arg1 = (wxRect *) 0 ;
6799 wxSize *arg2 = 0 ;
6800 void *argp1 = 0 ;
6801 int res1 = 0 ;
6802 wxSize temp2 ;
6803 PyObject * obj0 = 0 ;
6804 PyObject * obj1 = 0 ;
6805 char * kwnames[] = {
6806 (char *) "self",(char *) "s", NULL
6807 };
6808
6809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6811 if (!SWIG_IsOK(res1)) {
6812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6813 }
6814 arg1 = reinterpret_cast< wxRect * >(argp1);
6815 {
6816 arg2 = &temp2;
6817 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6818 }
6819 {
6820 (arg1)->SetSize((wxSize const &)*arg2);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_Py_Void();
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6831 PyObject *resultobj = 0;
6832 wxRect *arg1 = (wxRect *) 0 ;
6833 bool result;
6834 void *argp1 = 0 ;
6835 int res1 = 0 ;
6836 PyObject *swig_obj[1] ;
6837
6838 if (!args) SWIG_fail;
6839 swig_obj[0] = args;
6840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6841 if (!SWIG_IsOK(res1)) {
6842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6843 }
6844 arg1 = reinterpret_cast< wxRect * >(argp1);
6845 {
6846 result = (bool)((wxRect const *)arg1)->IsEmpty();
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 {
6850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6851 }
6852 return resultobj;
6853 fail:
6854 return NULL;
6855 }
6856
6857
6858 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6859 PyObject *resultobj = 0;
6860 wxRect *arg1 = (wxRect *) 0 ;
6861 wxPoint result;
6862 void *argp1 = 0 ;
6863 int res1 = 0 ;
6864 PyObject *swig_obj[1] ;
6865
6866 if (!args) SWIG_fail;
6867 swig_obj[0] = args;
6868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 {
6874 result = ((wxRect const *)arg1)->GetTopLeft();
6875 if (PyErr_Occurred()) SWIG_fail;
6876 }
6877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6878 return resultobj;
6879 fail:
6880 return NULL;
6881 }
6882
6883
6884 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6885 PyObject *resultobj = 0;
6886 wxRect *arg1 = (wxRect *) 0 ;
6887 wxPoint *arg2 = 0 ;
6888 void *argp1 = 0 ;
6889 int res1 = 0 ;
6890 wxPoint temp2 ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char * kwnames[] = {
6894 (char *) "self",(char *) "p", NULL
6895 };
6896
6897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 {
6904 arg2 = &temp2;
6905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6906 }
6907 {
6908 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6909 if (PyErr_Occurred()) SWIG_fail;
6910 }
6911 resultobj = SWIG_Py_Void();
6912 return resultobj;
6913 fail:
6914 return NULL;
6915 }
6916
6917
6918 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6919 PyObject *resultobj = 0;
6920 wxRect *arg1 = (wxRect *) 0 ;
6921 wxPoint result;
6922 void *argp1 = 0 ;
6923 int res1 = 0 ;
6924 PyObject *swig_obj[1] ;
6925
6926 if (!args) SWIG_fail;
6927 swig_obj[0] = args;
6928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6929 if (!SWIG_IsOK(res1)) {
6930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6931 }
6932 arg1 = reinterpret_cast< wxRect * >(argp1);
6933 {
6934 result = ((wxRect const *)arg1)->GetBottomRight();
6935 if (PyErr_Occurred()) SWIG_fail;
6936 }
6937 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6938 return resultobj;
6939 fail:
6940 return NULL;
6941 }
6942
6943
6944 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6945 PyObject *resultobj = 0;
6946 wxRect *arg1 = (wxRect *) 0 ;
6947 wxPoint *arg2 = 0 ;
6948 void *argp1 = 0 ;
6949 int res1 = 0 ;
6950 wxPoint temp2 ;
6951 PyObject * obj0 = 0 ;
6952 PyObject * obj1 = 0 ;
6953 char * kwnames[] = {
6954 (char *) "self",(char *) "p", NULL
6955 };
6956
6957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6959 if (!SWIG_IsOK(res1)) {
6960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6961 }
6962 arg1 = reinterpret_cast< wxRect * >(argp1);
6963 {
6964 arg2 = &temp2;
6965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6966 }
6967 {
6968 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 resultobj = SWIG_Py_Void();
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6979 PyObject *resultobj = 0;
6980 wxRect *arg1 = (wxRect *) 0 ;
6981 wxPoint result;
6982 void *argp1 = 0 ;
6983 int res1 = 0 ;
6984 PyObject *swig_obj[1] ;
6985
6986 if (!args) SWIG_fail;
6987 swig_obj[0] = args;
6988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6991 }
6992 arg1 = reinterpret_cast< wxRect * >(argp1);
6993 {
6994 result = ((wxRect const *)arg1)->GetTopRight();
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6998 return resultobj;
6999 fail:
7000 return NULL;
7001 }
7002
7003
7004 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7005 PyObject *resultobj = 0;
7006 wxRect *arg1 = (wxRect *) 0 ;
7007 wxPoint *arg2 = 0 ;
7008 void *argp1 = 0 ;
7009 int res1 = 0 ;
7010 wxPoint temp2 ;
7011 PyObject * obj0 = 0 ;
7012 PyObject * obj1 = 0 ;
7013 char * kwnames[] = {
7014 (char *) "self",(char *) "p", NULL
7015 };
7016
7017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7019 if (!SWIG_IsOK(res1)) {
7020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7021 }
7022 arg1 = reinterpret_cast< wxRect * >(argp1);
7023 {
7024 arg2 = &temp2;
7025 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7026 }
7027 {
7028 (arg1)->SetTopRight((wxPoint const &)*arg2);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_Py_Void();
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7039 PyObject *resultobj = 0;
7040 wxRect *arg1 = (wxRect *) 0 ;
7041 wxPoint result;
7042 void *argp1 = 0 ;
7043 int res1 = 0 ;
7044 PyObject *swig_obj[1] ;
7045
7046 if (!args) SWIG_fail;
7047 swig_obj[0] = args;
7048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7049 if (!SWIG_IsOK(res1)) {
7050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7051 }
7052 arg1 = reinterpret_cast< wxRect * >(argp1);
7053 {
7054 result = ((wxRect const *)arg1)->GetBottomLeft();
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 wxPoint *arg2 = 0 ;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 wxPoint temp2 ;
7071 PyObject * obj0 = 0 ;
7072 PyObject * obj1 = 0 ;
7073 char * kwnames[] = {
7074 (char *) "self",(char *) "p", NULL
7075 };
7076
7077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7079 if (!SWIG_IsOK(res1)) {
7080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7081 }
7082 arg1 = reinterpret_cast< wxRect * >(argp1);
7083 {
7084 arg2 = &temp2;
7085 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7086 }
7087 {
7088 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7089 if (PyErr_Occurred()) SWIG_fail;
7090 }
7091 resultobj = SWIG_Py_Void();
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7099 PyObject *resultobj = 0;
7100 wxRect *arg1 = (wxRect *) 0 ;
7101 int result;
7102 void *argp1 = 0 ;
7103 int res1 = 0 ;
7104 PyObject *swig_obj[1] ;
7105
7106 if (!args) SWIG_fail;
7107 swig_obj[0] = args;
7108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7109 if (!SWIG_IsOK(res1)) {
7110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7111 }
7112 arg1 = reinterpret_cast< wxRect * >(argp1);
7113 {
7114 result = (int)((wxRect const *)arg1)->GetLeft();
7115 if (PyErr_Occurred()) SWIG_fail;
7116 }
7117 resultobj = SWIG_From_int(static_cast< int >(result));
7118 return resultobj;
7119 fail:
7120 return NULL;
7121 }
7122
7123
7124 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7125 PyObject *resultobj = 0;
7126 wxRect *arg1 = (wxRect *) 0 ;
7127 int result;
7128 void *argp1 = 0 ;
7129 int res1 = 0 ;
7130 PyObject *swig_obj[1] ;
7131
7132 if (!args) SWIG_fail;
7133 swig_obj[0] = args;
7134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7135 if (!SWIG_IsOK(res1)) {
7136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7137 }
7138 arg1 = reinterpret_cast< wxRect * >(argp1);
7139 {
7140 result = (int)((wxRect const *)arg1)->GetTop();
7141 if (PyErr_Occurred()) SWIG_fail;
7142 }
7143 resultobj = SWIG_From_int(static_cast< int >(result));
7144 return resultobj;
7145 fail:
7146 return NULL;
7147 }
7148
7149
7150 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7151 PyObject *resultobj = 0;
7152 wxRect *arg1 = (wxRect *) 0 ;
7153 int result;
7154 void *argp1 = 0 ;
7155 int res1 = 0 ;
7156 PyObject *swig_obj[1] ;
7157
7158 if (!args) SWIG_fail;
7159 swig_obj[0] = args;
7160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7161 if (!SWIG_IsOK(res1)) {
7162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7163 }
7164 arg1 = reinterpret_cast< wxRect * >(argp1);
7165 {
7166 result = (int)((wxRect const *)arg1)->GetBottom();
7167 if (PyErr_Occurred()) SWIG_fail;
7168 }
7169 resultobj = SWIG_From_int(static_cast< int >(result));
7170 return resultobj;
7171 fail:
7172 return NULL;
7173 }
7174
7175
7176 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7177 PyObject *resultobj = 0;
7178 wxRect *arg1 = (wxRect *) 0 ;
7179 int result;
7180 void *argp1 = 0 ;
7181 int res1 = 0 ;
7182 PyObject *swig_obj[1] ;
7183
7184 if (!args) SWIG_fail;
7185 swig_obj[0] = args;
7186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7187 if (!SWIG_IsOK(res1)) {
7188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7189 }
7190 arg1 = reinterpret_cast< wxRect * >(argp1);
7191 {
7192 result = (int)((wxRect const *)arg1)->GetRight();
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_From_int(static_cast< int >(result));
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = 0;
7204 wxRect *arg1 = (wxRect *) 0 ;
7205 int arg2 ;
7206 void *argp1 = 0 ;
7207 int res1 = 0 ;
7208 int val2 ;
7209 int ecode2 = 0 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char * kwnames[] = {
7213 (char *) "self",(char *) "left", NULL
7214 };
7215
7216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7220 }
7221 arg1 = reinterpret_cast< wxRect * >(argp1);
7222 ecode2 = SWIG_AsVal_int(obj1, &val2);
7223 if (!SWIG_IsOK(ecode2)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7225 }
7226 arg2 = static_cast< int >(val2);
7227 {
7228 (arg1)->SetLeft(arg2);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 resultobj = SWIG_Py_Void();
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj = 0;
7240 wxRect *arg1 = (wxRect *) 0 ;
7241 int arg2 ;
7242 void *argp1 = 0 ;
7243 int res1 = 0 ;
7244 int val2 ;
7245 int ecode2 = 0 ;
7246 PyObject * obj0 = 0 ;
7247 PyObject * obj1 = 0 ;
7248 char * kwnames[] = {
7249 (char *) "self",(char *) "right", NULL
7250 };
7251
7252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7254 if (!SWIG_IsOK(res1)) {
7255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7256 }
7257 arg1 = reinterpret_cast< wxRect * >(argp1);
7258 ecode2 = SWIG_AsVal_int(obj1, &val2);
7259 if (!SWIG_IsOK(ecode2)) {
7260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7261 }
7262 arg2 = static_cast< int >(val2);
7263 {
7264 (arg1)->SetRight(arg2);
7265 if (PyErr_Occurred()) SWIG_fail;
7266 }
7267 resultobj = SWIG_Py_Void();
7268 return resultobj;
7269 fail:
7270 return NULL;
7271 }
7272
7273
7274 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7275 PyObject *resultobj = 0;
7276 wxRect *arg1 = (wxRect *) 0 ;
7277 int arg2 ;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 int val2 ;
7281 int ecode2 = 0 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 char * kwnames[] = {
7285 (char *) "self",(char *) "top", NULL
7286 };
7287
7288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7290 if (!SWIG_IsOK(res1)) {
7291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7292 }
7293 arg1 = reinterpret_cast< wxRect * >(argp1);
7294 ecode2 = SWIG_AsVal_int(obj1, &val2);
7295 if (!SWIG_IsOK(ecode2)) {
7296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7297 }
7298 arg2 = static_cast< int >(val2);
7299 {
7300 (arg1)->SetTop(arg2);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 resultobj = SWIG_Py_Void();
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj = 0;
7312 wxRect *arg1 = (wxRect *) 0 ;
7313 int arg2 ;
7314 void *argp1 = 0 ;
7315 int res1 = 0 ;
7316 int val2 ;
7317 int ecode2 = 0 ;
7318 PyObject * obj0 = 0 ;
7319 PyObject * obj1 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "bottom", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 ecode2 = SWIG_AsVal_int(obj1, &val2);
7331 if (!SWIG_IsOK(ecode2)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7333 }
7334 arg2 = static_cast< int >(val2);
7335 {
7336 (arg1)->SetBottom(arg2);
7337 if (PyErr_Occurred()) SWIG_fail;
7338 }
7339 resultobj = SWIG_Py_Void();
7340 return resultobj;
7341 fail:
7342 return NULL;
7343 }
7344
7345
7346 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7347 PyObject *resultobj = 0;
7348 wxRect *arg1 = (wxRect *) 0 ;
7349 int arg2 ;
7350 int arg3 ;
7351 wxRect result;
7352 void *argp1 = 0 ;
7353 int res1 = 0 ;
7354 int val2 ;
7355 int ecode2 = 0 ;
7356 int val3 ;
7357 int ecode3 = 0 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 PyObject * obj2 = 0 ;
7361 char * kwnames[] = {
7362 (char *) "self",(char *) "dx",(char *) "dy", NULL
7363 };
7364
7365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7367 if (!SWIG_IsOK(res1)) {
7368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7369 }
7370 arg1 = reinterpret_cast< wxRect * >(argp1);
7371 ecode2 = SWIG_AsVal_int(obj1, &val2);
7372 if (!SWIG_IsOK(ecode2)) {
7373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7374 }
7375 arg2 = static_cast< int >(val2);
7376 ecode3 = SWIG_AsVal_int(obj2, &val3);
7377 if (!SWIG_IsOK(ecode3)) {
7378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7379 }
7380 arg3 = static_cast< int >(val3);
7381 {
7382 result = (arg1)->Inflate(arg2,arg3);
7383 if (PyErr_Occurred()) SWIG_fail;
7384 }
7385 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7386 return resultobj;
7387 fail:
7388 return NULL;
7389 }
7390
7391
7392 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7393 PyObject *resultobj = 0;
7394 wxRect *arg1 = (wxRect *) 0 ;
7395 int arg2 ;
7396 int arg3 ;
7397 wxRect *result = 0 ;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 int val2 ;
7401 int ecode2 = 0 ;
7402 int val3 ;
7403 int ecode3 = 0 ;
7404 PyObject * obj0 = 0 ;
7405 PyObject * obj1 = 0 ;
7406 PyObject * obj2 = 0 ;
7407 char * kwnames[] = {
7408 (char *) "self",(char *) "dx",(char *) "dy", NULL
7409 };
7410
7411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7413 if (!SWIG_IsOK(res1)) {
7414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7415 }
7416 arg1 = reinterpret_cast< wxRect * >(argp1);
7417 ecode2 = SWIG_AsVal_int(obj1, &val2);
7418 if (!SWIG_IsOK(ecode2)) {
7419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7420 }
7421 arg2 = static_cast< int >(val2);
7422 ecode3 = SWIG_AsVal_int(obj2, &val3);
7423 if (!SWIG_IsOK(ecode3)) {
7424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7425 }
7426 arg3 = static_cast< int >(val3);
7427 {
7428 {
7429 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7430 result = (wxRect *) &_result_ref;
7431 }
7432 if (PyErr_Occurred()) SWIG_fail;
7433 }
7434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxRect *arg1 = (wxRect *) 0 ;
7444 int arg2 ;
7445 int arg3 ;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 int val2 ;
7449 int ecode2 = 0 ;
7450 int val3 ;
7451 int ecode3 = 0 ;
7452 PyObject * obj0 = 0 ;
7453 PyObject * obj1 = 0 ;
7454 PyObject * obj2 = 0 ;
7455 char * kwnames[] = {
7456 (char *) "self",(char *) "dx",(char *) "dy", NULL
7457 };
7458
7459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7461 if (!SWIG_IsOK(res1)) {
7462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7463 }
7464 arg1 = reinterpret_cast< wxRect * >(argp1);
7465 ecode2 = SWIG_AsVal_int(obj1, &val2);
7466 if (!SWIG_IsOK(ecode2)) {
7467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7468 }
7469 arg2 = static_cast< int >(val2);
7470 ecode3 = SWIG_AsVal_int(obj2, &val3);
7471 if (!SWIG_IsOK(ecode3)) {
7472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7473 }
7474 arg3 = static_cast< int >(val3);
7475 {
7476 (arg1)->Offset(arg2,arg3);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 resultobj = SWIG_Py_Void();
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj = 0;
7488 wxRect *arg1 = (wxRect *) 0 ;
7489 wxPoint *arg2 = 0 ;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 wxPoint temp2 ;
7493 PyObject * obj0 = 0 ;
7494 PyObject * obj1 = 0 ;
7495 char * kwnames[] = {
7496 (char *) "self",(char *) "pt", NULL
7497 };
7498
7499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7503 }
7504 arg1 = reinterpret_cast< wxRect * >(argp1);
7505 {
7506 arg2 = &temp2;
7507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7508 }
7509 {
7510 (arg1)->Offset((wxPoint const &)*arg2);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 resultobj = SWIG_Py_Void();
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7521 PyObject *resultobj = 0;
7522 wxRect *arg1 = (wxRect *) 0 ;
7523 wxRect *arg2 = 0 ;
7524 wxRect result;
7525 void *argp1 = 0 ;
7526 int res1 = 0 ;
7527 wxRect temp2 ;
7528 PyObject * obj0 = 0 ;
7529 PyObject * obj1 = 0 ;
7530 char * kwnames[] = {
7531 (char *) "self",(char *) "rect", NULL
7532 };
7533
7534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7536 if (!SWIG_IsOK(res1)) {
7537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7538 }
7539 arg1 = reinterpret_cast< wxRect * >(argp1);
7540 {
7541 arg2 = &temp2;
7542 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7543 }
7544 {
7545 result = (arg1)->Intersect((wxRect const &)*arg2);
7546 if (PyErr_Occurred()) SWIG_fail;
7547 }
7548 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj = 0;
7557 wxRect *arg1 = (wxRect *) 0 ;
7558 wxRect *arg2 = 0 ;
7559 wxRect result;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 wxRect temp2 ;
7563 PyObject * obj0 = 0 ;
7564 PyObject * obj1 = 0 ;
7565 char * kwnames[] = {
7566 (char *) "self",(char *) "rect", NULL
7567 };
7568
7569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7571 if (!SWIG_IsOK(res1)) {
7572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7573 }
7574 arg1 = reinterpret_cast< wxRect * >(argp1);
7575 {
7576 arg2 = &temp2;
7577 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7578 }
7579 {
7580 result = (arg1)->Union((wxRect const &)*arg2);
7581 if (PyErr_Occurred()) SWIG_fail;
7582 }
7583 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7584 return resultobj;
7585 fail:
7586 return NULL;
7587 }
7588
7589
7590 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7591 PyObject *resultobj = 0;
7592 wxRect *arg1 = (wxRect *) 0 ;
7593 wxRect *arg2 = 0 ;
7594 wxRect result;
7595 void *argp1 = 0 ;
7596 int res1 = 0 ;
7597 wxRect temp2 ;
7598 PyObject * obj0 = 0 ;
7599 PyObject * obj1 = 0 ;
7600 char * kwnames[] = {
7601 (char *) "self",(char *) "rect", NULL
7602 };
7603
7604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7606 if (!SWIG_IsOK(res1)) {
7607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7608 }
7609 arg1 = reinterpret_cast< wxRect * >(argp1);
7610 {
7611 arg2 = &temp2;
7612 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7613 }
7614 {
7615 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7616 if (PyErr_Occurred()) SWIG_fail;
7617 }
7618 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = 0;
7627 wxRect *arg1 = (wxRect *) 0 ;
7628 wxRect *arg2 = 0 ;
7629 wxRect *result = 0 ;
7630 void *argp1 = 0 ;
7631 int res1 = 0 ;
7632 wxRect temp2 ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 char * kwnames[] = {
7636 (char *) "self",(char *) "rect", NULL
7637 };
7638
7639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7641 if (!SWIG_IsOK(res1)) {
7642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7643 }
7644 arg1 = reinterpret_cast< wxRect * >(argp1);
7645 {
7646 arg2 = &temp2;
7647 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7648 }
7649 {
7650 {
7651 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7652 result = (wxRect *) &_result_ref;
7653 }
7654 if (PyErr_Occurred()) SWIG_fail;
7655 }
7656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7657 return resultobj;
7658 fail:
7659 return NULL;
7660 }
7661
7662
7663 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7664 PyObject *resultobj = 0;
7665 wxRect *arg1 = (wxRect *) 0 ;
7666 PyObject *arg2 = (PyObject *) 0 ;
7667 bool result;
7668 void *argp1 = 0 ;
7669 int res1 = 0 ;
7670 PyObject * obj0 = 0 ;
7671 PyObject * obj1 = 0 ;
7672 char * kwnames[] = {
7673 (char *) "self",(char *) "other", NULL
7674 };
7675
7676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7678 if (!SWIG_IsOK(res1)) {
7679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7680 }
7681 arg1 = reinterpret_cast< wxRect * >(argp1);
7682 arg2 = obj1;
7683 {
7684 result = (bool)wxRect___eq__(arg1,arg2);
7685 if (PyErr_Occurred()) SWIG_fail;
7686 }
7687 {
7688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7689 }
7690 return resultobj;
7691 fail:
7692 return NULL;
7693 }
7694
7695
7696 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj = 0;
7698 wxRect *arg1 = (wxRect *) 0 ;
7699 PyObject *arg2 = (PyObject *) 0 ;
7700 bool result;
7701 void *argp1 = 0 ;
7702 int res1 = 0 ;
7703 PyObject * obj0 = 0 ;
7704 PyObject * obj1 = 0 ;
7705 char * kwnames[] = {
7706 (char *) "self",(char *) "other", NULL
7707 };
7708
7709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7711 if (!SWIG_IsOK(res1)) {
7712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7713 }
7714 arg1 = reinterpret_cast< wxRect * >(argp1);
7715 arg2 = obj1;
7716 {
7717 result = (bool)wxRect___ne__(arg1,arg2);
7718 if (PyErr_Occurred()) SWIG_fail;
7719 }
7720 {
7721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7722 }
7723 return resultobj;
7724 fail:
7725 return NULL;
7726 }
7727
7728
7729 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7730 PyObject *resultobj = 0;
7731 wxRect *arg1 = (wxRect *) 0 ;
7732 int arg2 ;
7733 int arg3 ;
7734 bool result;
7735 void *argp1 = 0 ;
7736 int res1 = 0 ;
7737 int val2 ;
7738 int ecode2 = 0 ;
7739 int val3 ;
7740 int ecode3 = 0 ;
7741 PyObject * obj0 = 0 ;
7742 PyObject * obj1 = 0 ;
7743 PyObject * obj2 = 0 ;
7744 char * kwnames[] = {
7745 (char *) "self",(char *) "x",(char *) "y", NULL
7746 };
7747
7748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7750 if (!SWIG_IsOK(res1)) {
7751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7752 }
7753 arg1 = reinterpret_cast< wxRect * >(argp1);
7754 ecode2 = SWIG_AsVal_int(obj1, &val2);
7755 if (!SWIG_IsOK(ecode2)) {
7756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7757 }
7758 arg2 = static_cast< int >(val2);
7759 ecode3 = SWIG_AsVal_int(obj2, &val3);
7760 if (!SWIG_IsOK(ecode3)) {
7761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7762 }
7763 arg3 = static_cast< int >(val3);
7764 {
7765 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj = 0;
7779 wxRect *arg1 = (wxRect *) 0 ;
7780 wxPoint *arg2 = 0 ;
7781 bool result;
7782 void *argp1 = 0 ;
7783 int res1 = 0 ;
7784 wxPoint temp2 ;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 char * kwnames[] = {
7788 (char *) "self",(char *) "pt", NULL
7789 };
7790
7791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7795 }
7796 arg1 = reinterpret_cast< wxRect * >(argp1);
7797 {
7798 arg2 = &temp2;
7799 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7800 }
7801 {
7802 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 {
7806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7807 }
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 wxRect *arg2 = 0 ;
7818 bool result;
7819 void *argp1 = 0 ;
7820 int res1 = 0 ;
7821 wxRect temp2 ;
7822 PyObject * obj0 = 0 ;
7823 PyObject * obj1 = 0 ;
7824 char * kwnames[] = {
7825 (char *) "self",(char *) "rect", NULL
7826 };
7827
7828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7830 if (!SWIG_IsOK(res1)) {
7831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7832 }
7833 arg1 = reinterpret_cast< wxRect * >(argp1);
7834 {
7835 arg2 = &temp2;
7836 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7837 }
7838 {
7839 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7840 if (PyErr_Occurred()) SWIG_fail;
7841 }
7842 {
7843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7844 }
7845 return resultobj;
7846 fail:
7847 return NULL;
7848 }
7849
7850
7851 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7852 PyObject *resultobj = 0;
7853 wxRect *arg1 = (wxRect *) 0 ;
7854 wxRect *arg2 = 0 ;
7855 bool result;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 wxRect temp2 ;
7859 PyObject * obj0 = 0 ;
7860 PyObject * obj1 = 0 ;
7861 char * kwnames[] = {
7862 (char *) "self",(char *) "rect", NULL
7863 };
7864
7865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7867 if (!SWIG_IsOK(res1)) {
7868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7869 }
7870 arg1 = reinterpret_cast< wxRect * >(argp1);
7871 {
7872 arg2 = &temp2;
7873 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7874 }
7875 {
7876 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7877 if (PyErr_Occurred()) SWIG_fail;
7878 }
7879 {
7880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7881 }
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7889 PyObject *resultobj = 0;
7890 wxRect *arg1 = (wxRect *) 0 ;
7891 wxRect *arg2 = 0 ;
7892 int arg3 = (int) wxBOTH ;
7893 wxRect result;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 wxRect temp2 ;
7897 int val3 ;
7898 int ecode3 = 0 ;
7899 PyObject * obj0 = 0 ;
7900 PyObject * obj1 = 0 ;
7901 PyObject * obj2 = 0 ;
7902 char * kwnames[] = {
7903 (char *) "self",(char *) "r",(char *) "dir", NULL
7904 };
7905
7906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7910 }
7911 arg1 = reinterpret_cast< wxRect * >(argp1);
7912 {
7913 arg2 = &temp2;
7914 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7915 }
7916 if (obj2) {
7917 ecode3 = SWIG_AsVal_int(obj2, &val3);
7918 if (!SWIG_IsOK(ecode3)) {
7919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7920 }
7921 arg3 = static_cast< int >(val3);
7922 }
7923 {
7924 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7935 PyObject *resultobj = 0;
7936 wxRect *arg1 = (wxRect *) 0 ;
7937 int arg2 ;
7938 void *argp1 = 0 ;
7939 int res1 = 0 ;
7940 int val2 ;
7941 int ecode2 = 0 ;
7942 PyObject *swig_obj[2] ;
7943
7944 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7946 if (!SWIG_IsOK(res1)) {
7947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7948 }
7949 arg1 = reinterpret_cast< wxRect * >(argp1);
7950 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7951 if (!SWIG_IsOK(ecode2)) {
7952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7953 }
7954 arg2 = static_cast< int >(val2);
7955 if (arg1) (arg1)->x = arg2;
7956
7957 resultobj = SWIG_Py_Void();
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7965 PyObject *resultobj = 0;
7966 wxRect *arg1 = (wxRect *) 0 ;
7967 int result;
7968 void *argp1 = 0 ;
7969 int res1 = 0 ;
7970 PyObject *swig_obj[1] ;
7971
7972 if (!args) SWIG_fail;
7973 swig_obj[0] = args;
7974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7975 if (!SWIG_IsOK(res1)) {
7976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7977 }
7978 arg1 = reinterpret_cast< wxRect * >(argp1);
7979 result = (int) ((arg1)->x);
7980 resultobj = SWIG_From_int(static_cast< int >(result));
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7988 PyObject *resultobj = 0;
7989 wxRect *arg1 = (wxRect *) 0 ;
7990 int arg2 ;
7991 void *argp1 = 0 ;
7992 int res1 = 0 ;
7993 int val2 ;
7994 int ecode2 = 0 ;
7995 PyObject *swig_obj[2] ;
7996
7997 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7999 if (!SWIG_IsOK(res1)) {
8000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8001 }
8002 arg1 = reinterpret_cast< wxRect * >(argp1);
8003 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8004 if (!SWIG_IsOK(ecode2)) {
8005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8006 }
8007 arg2 = static_cast< int >(val2);
8008 if (arg1) (arg1)->y = arg2;
8009
8010 resultobj = SWIG_Py_Void();
8011 return resultobj;
8012 fail:
8013 return NULL;
8014 }
8015
8016
8017 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8018 PyObject *resultobj = 0;
8019 wxRect *arg1 = (wxRect *) 0 ;
8020 int result;
8021 void *argp1 = 0 ;
8022 int res1 = 0 ;
8023 PyObject *swig_obj[1] ;
8024
8025 if (!args) SWIG_fail;
8026 swig_obj[0] = args;
8027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8028 if (!SWIG_IsOK(res1)) {
8029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8030 }
8031 arg1 = reinterpret_cast< wxRect * >(argp1);
8032 result = (int) ((arg1)->y);
8033 resultobj = SWIG_From_int(static_cast< int >(result));
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8041 PyObject *resultobj = 0;
8042 wxRect *arg1 = (wxRect *) 0 ;
8043 int arg2 ;
8044 void *argp1 = 0 ;
8045 int res1 = 0 ;
8046 int val2 ;
8047 int ecode2 = 0 ;
8048 PyObject *swig_obj[2] ;
8049
8050 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8052 if (!SWIG_IsOK(res1)) {
8053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8054 }
8055 arg1 = reinterpret_cast< wxRect * >(argp1);
8056 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8057 if (!SWIG_IsOK(ecode2)) {
8058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8059 }
8060 arg2 = static_cast< int >(val2);
8061 if (arg1) (arg1)->width = arg2;
8062
8063 resultobj = SWIG_Py_Void();
8064 return resultobj;
8065 fail:
8066 return NULL;
8067 }
8068
8069
8070 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8071 PyObject *resultobj = 0;
8072 wxRect *arg1 = (wxRect *) 0 ;
8073 int result;
8074 void *argp1 = 0 ;
8075 int res1 = 0 ;
8076 PyObject *swig_obj[1] ;
8077
8078 if (!args) SWIG_fail;
8079 swig_obj[0] = args;
8080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8081 if (!SWIG_IsOK(res1)) {
8082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8083 }
8084 arg1 = reinterpret_cast< wxRect * >(argp1);
8085 result = (int) ((arg1)->width);
8086 resultobj = SWIG_From_int(static_cast< int >(result));
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8094 PyObject *resultobj = 0;
8095 wxRect *arg1 = (wxRect *) 0 ;
8096 int arg2 ;
8097 void *argp1 = 0 ;
8098 int res1 = 0 ;
8099 int val2 ;
8100 int ecode2 = 0 ;
8101 PyObject *swig_obj[2] ;
8102
8103 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8105 if (!SWIG_IsOK(res1)) {
8106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8107 }
8108 arg1 = reinterpret_cast< wxRect * >(argp1);
8109 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8110 if (!SWIG_IsOK(ecode2)) {
8111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8112 }
8113 arg2 = static_cast< int >(val2);
8114 if (arg1) (arg1)->height = arg2;
8115
8116 resultobj = SWIG_Py_Void();
8117 return resultobj;
8118 fail:
8119 return NULL;
8120 }
8121
8122
8123 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8124 PyObject *resultobj = 0;
8125 wxRect *arg1 = (wxRect *) 0 ;
8126 int result;
8127 void *argp1 = 0 ;
8128 int res1 = 0 ;
8129 PyObject *swig_obj[1] ;
8130
8131 if (!args) SWIG_fail;
8132 swig_obj[0] = args;
8133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8134 if (!SWIG_IsOK(res1)) {
8135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8136 }
8137 arg1 = reinterpret_cast< wxRect * >(argp1);
8138 result = (int) ((arg1)->height);
8139 resultobj = SWIG_From_int(static_cast< int >(result));
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8147 PyObject *resultobj = 0;
8148 wxRect *arg1 = (wxRect *) 0 ;
8149 int arg2 = (int) 0 ;
8150 int arg3 = (int) 0 ;
8151 int arg4 = (int) 0 ;
8152 int arg5 = (int) 0 ;
8153 void *argp1 = 0 ;
8154 int res1 = 0 ;
8155 int val2 ;
8156 int ecode2 = 0 ;
8157 int val3 ;
8158 int ecode3 = 0 ;
8159 int val4 ;
8160 int ecode4 = 0 ;
8161 int val5 ;
8162 int ecode5 = 0 ;
8163 PyObject * obj0 = 0 ;
8164 PyObject * obj1 = 0 ;
8165 PyObject * obj2 = 0 ;
8166 PyObject * obj3 = 0 ;
8167 PyObject * obj4 = 0 ;
8168 char * kwnames[] = {
8169 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8170 };
8171
8172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8174 if (!SWIG_IsOK(res1)) {
8175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8176 }
8177 arg1 = reinterpret_cast< wxRect * >(argp1);
8178 if (obj1) {
8179 ecode2 = SWIG_AsVal_int(obj1, &val2);
8180 if (!SWIG_IsOK(ecode2)) {
8181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8182 }
8183 arg2 = static_cast< int >(val2);
8184 }
8185 if (obj2) {
8186 ecode3 = SWIG_AsVal_int(obj2, &val3);
8187 if (!SWIG_IsOK(ecode3)) {
8188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8189 }
8190 arg3 = static_cast< int >(val3);
8191 }
8192 if (obj3) {
8193 ecode4 = SWIG_AsVal_int(obj3, &val4);
8194 if (!SWIG_IsOK(ecode4)) {
8195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8196 }
8197 arg4 = static_cast< int >(val4);
8198 }
8199 if (obj4) {
8200 ecode5 = SWIG_AsVal_int(obj4, &val5);
8201 if (!SWIG_IsOK(ecode5)) {
8202 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8203 }
8204 arg5 = static_cast< int >(val5);
8205 }
8206 {
8207 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8208 if (PyErr_Occurred()) SWIG_fail;
8209 }
8210 resultobj = SWIG_Py_Void();
8211 return resultobj;
8212 fail:
8213 return NULL;
8214 }
8215
8216
8217 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8218 PyObject *resultobj = 0;
8219 wxRect *arg1 = (wxRect *) 0 ;
8220 PyObject *result = 0 ;
8221 void *argp1 = 0 ;
8222 int res1 = 0 ;
8223 PyObject *swig_obj[1] ;
8224
8225 if (!args) SWIG_fail;
8226 swig_obj[0] = args;
8227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8228 if (!SWIG_IsOK(res1)) {
8229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8230 }
8231 arg1 = reinterpret_cast< wxRect * >(argp1);
8232 {
8233 result = (PyObject *)wxRect_Get(arg1);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = result;
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8244 PyObject *obj;
8245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8246 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8247 return SWIG_Py_Void();
8248 }
8249
8250 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 return SWIG_Python_InitShadowInstance(args);
8252 }
8253
8254 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj = 0;
8256 wxRect *arg1 = (wxRect *) 0 ;
8257 wxRect *arg2 = (wxRect *) 0 ;
8258 PyObject *result = 0 ;
8259 void *argp1 = 0 ;
8260 int res1 = 0 ;
8261 void *argp2 = 0 ;
8262 int res2 = 0 ;
8263 PyObject * obj0 = 0 ;
8264 PyObject * obj1 = 0 ;
8265 char * kwnames[] = {
8266 (char *) "r1",(char *) "r2", NULL
8267 };
8268
8269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8271 if (!SWIG_IsOK(res1)) {
8272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8273 }
8274 arg1 = reinterpret_cast< wxRect * >(argp1);
8275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8276 if (!SWIG_IsOK(res2)) {
8277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8278 }
8279 arg2 = reinterpret_cast< wxRect * >(argp2);
8280 {
8281 if (!wxPyCheckForApp()) SWIG_fail;
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (PyObject *)wxIntersectRect(arg1,arg2);
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = result;
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj = 0;
8296 double arg1 = (double) 0.0 ;
8297 double arg2 = (double) 0.0 ;
8298 wxPoint2D *result = 0 ;
8299 double val1 ;
8300 int ecode1 = 0 ;
8301 double val2 ;
8302 int ecode2 = 0 ;
8303 PyObject * obj0 = 0 ;
8304 PyObject * obj1 = 0 ;
8305 char * kwnames[] = {
8306 (char *) "x",(char *) "y", NULL
8307 };
8308
8309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8310 if (obj0) {
8311 ecode1 = SWIG_AsVal_double(obj0, &val1);
8312 if (!SWIG_IsOK(ecode1)) {
8313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8314 }
8315 arg1 = static_cast< double >(val1);
8316 }
8317 if (obj1) {
8318 ecode2 = SWIG_AsVal_double(obj1, &val2);
8319 if (!SWIG_IsOK(ecode2)) {
8320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8321 }
8322 arg2 = static_cast< double >(val2);
8323 }
8324 {
8325 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8326 if (PyErr_Occurred()) SWIG_fail;
8327 }
8328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8329 return resultobj;
8330 fail:
8331 return NULL;
8332 }
8333
8334
8335 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8336 PyObject *resultobj = 0;
8337 wxPoint2D *arg1 = 0 ;
8338 wxPoint2D *result = 0 ;
8339 wxPoint2D temp1 ;
8340 PyObject * obj0 = 0 ;
8341 char * kwnames[] = {
8342 (char *) "pt", NULL
8343 };
8344
8345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8346 {
8347 arg1 = &temp1;
8348 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8349 }
8350 {
8351 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint *arg1 = 0 ;
8364 wxPoint2D *result = 0 ;
8365 wxPoint temp1 ;
8366 PyObject * obj0 = 0 ;
8367 char * kwnames[] = {
8368 (char *) "pt", NULL
8369 };
8370
8371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8372 {
8373 arg1 = &temp1;
8374 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8375 }
8376 {
8377 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8378 if (PyErr_Occurred()) SWIG_fail;
8379 }
8380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8388 PyObject *resultobj = 0;
8389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8390 void *argp1 = 0 ;
8391 int res1 = 0 ;
8392 PyObject *swig_obj[1] ;
8393
8394 if (!args) SWIG_fail;
8395 swig_obj[0] = args;
8396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8397 if (!SWIG_IsOK(res1)) {
8398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8399 }
8400 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8401 {
8402 delete arg1;
8403
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_Py_Void();
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8414 PyObject *resultobj = 0;
8415 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8416 int *arg2 = (int *) 0 ;
8417 int *arg3 = (int *) 0 ;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 int temp2 ;
8421 int res2 = SWIG_TMPOBJ ;
8422 int temp3 ;
8423 int res3 = SWIG_TMPOBJ ;
8424 PyObject *swig_obj[1] ;
8425
8426 arg2 = &temp2;
8427 arg3 = &temp3;
8428 if (!args) SWIG_fail;
8429 swig_obj[0] = args;
8430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8431 if (!SWIG_IsOK(res1)) {
8432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8433 }
8434 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8435 {
8436 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8437 if (PyErr_Occurred()) SWIG_fail;
8438 }
8439 resultobj = SWIG_Py_Void();
8440 if (SWIG_IsTmpObj(res2)) {
8441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8442 } else {
8443 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8445 }
8446 if (SWIG_IsTmpObj(res3)) {
8447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8448 } else {
8449 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8451 }
8452 return resultobj;
8453 fail:
8454 return NULL;
8455 }
8456
8457
8458 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8459 PyObject *resultobj = 0;
8460 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8461 int *arg2 = (int *) 0 ;
8462 int *arg3 = (int *) 0 ;
8463 void *argp1 = 0 ;
8464 int res1 = 0 ;
8465 int temp2 ;
8466 int res2 = SWIG_TMPOBJ ;
8467 int temp3 ;
8468 int res3 = SWIG_TMPOBJ ;
8469 PyObject *swig_obj[1] ;
8470
8471 arg2 = &temp2;
8472 arg3 = &temp3;
8473 if (!args) SWIG_fail;
8474 swig_obj[0] = args;
8475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8476 if (!SWIG_IsOK(res1)) {
8477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8478 }
8479 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8480 {
8481 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 resultobj = SWIG_Py_Void();
8485 if (SWIG_IsTmpObj(res2)) {
8486 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8487 } else {
8488 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8489 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8490 }
8491 if (SWIG_IsTmpObj(res3)) {
8492 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8493 } else {
8494 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8495 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8504 PyObject *resultobj = 0;
8505 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8506 double result;
8507 void *argp1 = 0 ;
8508 int res1 = 0 ;
8509 PyObject *swig_obj[1] ;
8510
8511 if (!args) SWIG_fail;
8512 swig_obj[0] = args;
8513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8514 if (!SWIG_IsOK(res1)) {
8515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8516 }
8517 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8518 {
8519 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8520 if (PyErr_Occurred()) SWIG_fail;
8521 }
8522 resultobj = SWIG_From_double(static_cast< double >(result));
8523 return resultobj;
8524 fail:
8525 return NULL;
8526 }
8527
8528
8529 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8530 PyObject *resultobj = 0;
8531 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8532 double result;
8533 void *argp1 = 0 ;
8534 int res1 = 0 ;
8535 PyObject *swig_obj[1] ;
8536
8537 if (!args) SWIG_fail;
8538 swig_obj[0] = args;
8539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8540 if (!SWIG_IsOK(res1)) {
8541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8542 }
8543 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8544 {
8545 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_From_double(static_cast< double >(result));
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 double arg2 ;
8559 void *argp1 = 0 ;
8560 int res1 = 0 ;
8561 double val2 ;
8562 int ecode2 = 0 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "length", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 ecode2 = SWIG_AsVal_double(obj1, &val2);
8576 if (!SWIG_IsOK(ecode2)) {
8577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8578 }
8579 arg2 = static_cast< double >(val2);
8580 {
8581 (arg1)->SetVectorLength(arg2);
8582 if (PyErr_Occurred()) SWIG_fail;
8583 }
8584 resultobj = SWIG_Py_Void();
8585 return resultobj;
8586 fail:
8587 return NULL;
8588 }
8589
8590
8591 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8592 PyObject *resultobj = 0;
8593 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8594 double arg2 ;
8595 void *argp1 = 0 ;
8596 int res1 = 0 ;
8597 double val2 ;
8598 int ecode2 = 0 ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char * kwnames[] = {
8602 (char *) "self",(char *) "degrees", NULL
8603 };
8604
8605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8607 if (!SWIG_IsOK(res1)) {
8608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8609 }
8610 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8611 ecode2 = SWIG_AsVal_double(obj1, &val2);
8612 if (!SWIG_IsOK(ecode2)) {
8613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8614 }
8615 arg2 = static_cast< double >(val2);
8616 {
8617 (arg1)->SetVectorAngle(arg2);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 resultobj = SWIG_Py_Void();
8621 return resultobj;
8622 fail:
8623 return NULL;
8624 }
8625
8626
8627 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8628 PyObject *resultobj = 0;
8629 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8630 wxPoint2D *arg2 = 0 ;
8631 double result;
8632 void *argp1 = 0 ;
8633 int res1 = 0 ;
8634 wxPoint2D temp2 ;
8635 PyObject * obj0 = 0 ;
8636 PyObject * obj1 = 0 ;
8637 char * kwnames[] = {
8638 (char *) "self",(char *) "pt", NULL
8639 };
8640
8641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8643 if (!SWIG_IsOK(res1)) {
8644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8645 }
8646 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8647 {
8648 arg2 = &temp2;
8649 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8650 }
8651 {
8652 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8653 if (PyErr_Occurred()) SWIG_fail;
8654 }
8655 resultobj = SWIG_From_double(static_cast< double >(result));
8656 return resultobj;
8657 fail:
8658 return NULL;
8659 }
8660
8661
8662 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8663 PyObject *resultobj = 0;
8664 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8665 wxPoint2D *arg2 = 0 ;
8666 double result;
8667 void *argp1 = 0 ;
8668 int res1 = 0 ;
8669 wxPoint2D temp2 ;
8670 PyObject * obj0 = 0 ;
8671 PyObject * obj1 = 0 ;
8672 char * kwnames[] = {
8673 (char *) "self",(char *) "pt", NULL
8674 };
8675
8676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8678 if (!SWIG_IsOK(res1)) {
8679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8680 }
8681 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8682 {
8683 arg2 = &temp2;
8684 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8685 }
8686 {
8687 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8688 if (PyErr_Occurred()) SWIG_fail;
8689 }
8690 resultobj = SWIG_From_double(static_cast< double >(result));
8691 return resultobj;
8692 fail:
8693 return NULL;
8694 }
8695
8696
8697 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8698 PyObject *resultobj = 0;
8699 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8700 wxPoint2D *arg2 = 0 ;
8701 double result;
8702 void *argp1 = 0 ;
8703 int res1 = 0 ;
8704 wxPoint2D temp2 ;
8705 PyObject * obj0 = 0 ;
8706 PyObject * obj1 = 0 ;
8707 char * kwnames[] = {
8708 (char *) "self",(char *) "vec", NULL
8709 };
8710
8711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8713 if (!SWIG_IsOK(res1)) {
8714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8715 }
8716 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8717 {
8718 arg2 = &temp2;
8719 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8720 }
8721 {
8722 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8723 if (PyErr_Occurred()) SWIG_fail;
8724 }
8725 resultobj = SWIG_From_double(static_cast< double >(result));
8726 return resultobj;
8727 fail:
8728 return NULL;
8729 }
8730
8731
8732 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj = 0;
8734 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8735 wxPoint2D *arg2 = 0 ;
8736 double result;
8737 void *argp1 = 0 ;
8738 int res1 = 0 ;
8739 wxPoint2D temp2 ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 char * kwnames[] = {
8743 (char *) "self",(char *) "vec", NULL
8744 };
8745
8746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 {
8753 arg2 = &temp2;
8754 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8755 }
8756 {
8757 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8758 if (PyErr_Occurred()) SWIG_fail;
8759 }
8760 resultobj = SWIG_From_double(static_cast< double >(result));
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 wxPoint2D result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject *swig_obj[1] ;
8774
8775 if (!args) SWIG_fail;
8776 swig_obj[0] = args;
8777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8778 if (!SWIG_IsOK(res1)) {
8779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8780 }
8781 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8782 {
8783 result = (arg1)->operator -();
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj = 0;
8795 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8796 wxPoint2D *arg2 = 0 ;
8797 wxPoint2D *result = 0 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 wxPoint2D temp2 ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "pt", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 {
8814 arg2 = &temp2;
8815 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8816 }
8817 {
8818 {
8819 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8820 result = (wxPoint2D *) &_result_ref;
8821 }
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8832 PyObject *resultobj = 0;
8833 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8834 wxPoint2D *arg2 = 0 ;
8835 wxPoint2D *result = 0 ;
8836 void *argp1 = 0 ;
8837 int res1 = 0 ;
8838 wxPoint2D temp2 ;
8839 PyObject * obj0 = 0 ;
8840 PyObject * obj1 = 0 ;
8841 char * kwnames[] = {
8842 (char *) "self",(char *) "pt", NULL
8843 };
8844
8845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8847 if (!SWIG_IsOK(res1)) {
8848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8849 }
8850 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8851 {
8852 arg2 = &temp2;
8853 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8854 }
8855 {
8856 {
8857 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8858 result = (wxPoint2D *) &_result_ref;
8859 }
8860 if (PyErr_Occurred()) SWIG_fail;
8861 }
8862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj = 0;
8871 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8872 wxPoint2D *arg2 = 0 ;
8873 wxPoint2D *result = 0 ;
8874 void *argp1 = 0 ;
8875 int res1 = 0 ;
8876 wxPoint2D temp2 ;
8877 PyObject * obj0 = 0 ;
8878 PyObject * obj1 = 0 ;
8879 char * kwnames[] = {
8880 (char *) "self",(char *) "pt", NULL
8881 };
8882
8883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8885 if (!SWIG_IsOK(res1)) {
8886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8887 }
8888 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8889 {
8890 arg2 = &temp2;
8891 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8892 }
8893 {
8894 {
8895 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8896 result = (wxPoint2D *) &_result_ref;
8897 }
8898 if (PyErr_Occurred()) SWIG_fail;
8899 }
8900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8910 wxPoint2D *arg2 = 0 ;
8911 wxPoint2D *result = 0 ;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 wxPoint2D temp2 ;
8915 PyObject * obj0 = 0 ;
8916 PyObject * obj1 = 0 ;
8917 char * kwnames[] = {
8918 (char *) "self",(char *) "pt", NULL
8919 };
8920
8921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8923 if (!SWIG_IsOK(res1)) {
8924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8925 }
8926 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8927 {
8928 arg2 = &temp2;
8929 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8930 }
8931 {
8932 {
8933 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8934 result = (wxPoint2D *) &_result_ref;
8935 }
8936 if (PyErr_Occurred()) SWIG_fail;
8937 }
8938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8939 return resultobj;
8940 fail:
8941 return NULL;
8942 }
8943
8944
8945 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8946 PyObject *resultobj = 0;
8947 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8948 PyObject *arg2 = (PyObject *) 0 ;
8949 bool result;
8950 void *argp1 = 0 ;
8951 int res1 = 0 ;
8952 PyObject * obj0 = 0 ;
8953 PyObject * obj1 = 0 ;
8954 char * kwnames[] = {
8955 (char *) "self",(char *) "other", NULL
8956 };
8957
8958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8960 if (!SWIG_IsOK(res1)) {
8961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8962 }
8963 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8964 arg2 = obj1;
8965 {
8966 result = (bool)wxPoint2D___eq__(arg1,arg2);
8967 if (PyErr_Occurred()) SWIG_fail;
8968 }
8969 {
8970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8971 }
8972 return resultobj;
8973 fail:
8974 return NULL;
8975 }
8976
8977
8978 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj = 0;
8980 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8981 PyObject *arg2 = (PyObject *) 0 ;
8982 bool result;
8983 void *argp1 = 0 ;
8984 int res1 = 0 ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 char * kwnames[] = {
8988 (char *) "self",(char *) "other", NULL
8989 };
8990
8991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8997 arg2 = obj1;
8998 {
8999 result = (bool)wxPoint2D___ne__(arg1,arg2);
9000 if (PyErr_Occurred()) SWIG_fail;
9001 }
9002 {
9003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9004 }
9005 return resultobj;
9006 fail:
9007 return NULL;
9008 }
9009
9010
9011 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9012 PyObject *resultobj = 0;
9013 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9014 double arg2 ;
9015 void *argp1 = 0 ;
9016 int res1 = 0 ;
9017 double val2 ;
9018 int ecode2 = 0 ;
9019 PyObject *swig_obj[2] ;
9020
9021 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9023 if (!SWIG_IsOK(res1)) {
9024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9025 }
9026 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9027 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9028 if (!SWIG_IsOK(ecode2)) {
9029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9030 }
9031 arg2 = static_cast< double >(val2);
9032 if (arg1) (arg1)->m_x = arg2;
9033
9034 resultobj = SWIG_Py_Void();
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9042 PyObject *resultobj = 0;
9043 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9044 double result;
9045 void *argp1 = 0 ;
9046 int res1 = 0 ;
9047 PyObject *swig_obj[1] ;
9048
9049 if (!args) SWIG_fail;
9050 swig_obj[0] = args;
9051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9052 if (!SWIG_IsOK(res1)) {
9053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9054 }
9055 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9056 result = (double) ((arg1)->m_x);
9057 resultobj = SWIG_From_double(static_cast< double >(result));
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 PyObject *resultobj = 0;
9066 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9067 double arg2 ;
9068 void *argp1 = 0 ;
9069 int res1 = 0 ;
9070 double val2 ;
9071 int ecode2 = 0 ;
9072 PyObject *swig_obj[2] ;
9073
9074 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9076 if (!SWIG_IsOK(res1)) {
9077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9078 }
9079 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9080 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9081 if (!SWIG_IsOK(ecode2)) {
9082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9083 }
9084 arg2 = static_cast< double >(val2);
9085 if (arg1) (arg1)->m_y = arg2;
9086
9087 resultobj = SWIG_Py_Void();
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9095 PyObject *resultobj = 0;
9096 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9097 double result;
9098 void *argp1 = 0 ;
9099 int res1 = 0 ;
9100 PyObject *swig_obj[1] ;
9101
9102 if (!args) SWIG_fail;
9103 swig_obj[0] = args;
9104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9105 if (!SWIG_IsOK(res1)) {
9106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9107 }
9108 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9109 result = (double) ((arg1)->m_y);
9110 resultobj = SWIG_From_double(static_cast< double >(result));
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = 0;
9119 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9120 double arg2 = (double) 0 ;
9121 double arg3 = (double) 0 ;
9122 void *argp1 = 0 ;
9123 int res1 = 0 ;
9124 double val2 ;
9125 int ecode2 = 0 ;
9126 double val3 ;
9127 int ecode3 = 0 ;
9128 PyObject * obj0 = 0 ;
9129 PyObject * obj1 = 0 ;
9130 PyObject * obj2 = 0 ;
9131 char * kwnames[] = {
9132 (char *) "self",(char *) "x",(char *) "y", NULL
9133 };
9134
9135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9137 if (!SWIG_IsOK(res1)) {
9138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9139 }
9140 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9141 if (obj1) {
9142 ecode2 = SWIG_AsVal_double(obj1, &val2);
9143 if (!SWIG_IsOK(ecode2)) {
9144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9145 }
9146 arg2 = static_cast< double >(val2);
9147 }
9148 if (obj2) {
9149 ecode3 = SWIG_AsVal_double(obj2, &val3);
9150 if (!SWIG_IsOK(ecode3)) {
9151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9152 }
9153 arg3 = static_cast< double >(val3);
9154 }
9155 {
9156 wxPoint2D_Set(arg1,arg2,arg3);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 resultobj = SWIG_Py_Void();
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9167 PyObject *resultobj = 0;
9168 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9169 PyObject *result = 0 ;
9170 void *argp1 = 0 ;
9171 int res1 = 0 ;
9172 PyObject *swig_obj[1] ;
9173
9174 if (!args) SWIG_fail;
9175 swig_obj[0] = args;
9176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9177 if (!SWIG_IsOK(res1)) {
9178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9179 }
9180 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9181 {
9182 result = (PyObject *)wxPoint2D_Get(arg1);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 resultobj = result;
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9193 PyObject *obj;
9194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9195 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9196 return SWIG_Py_Void();
9197 }
9198
9199 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9200 return SWIG_Python_InitShadowInstance(args);
9201 }
9202
9203 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9204 PyObject *resultobj = 0;
9205 wxDouble arg1 = (wxDouble) 0.0 ;
9206 wxDouble arg2 = (wxDouble) 0.0 ;
9207 wxDouble arg3 = (wxDouble) 0.0 ;
9208 wxDouble arg4 = (wxDouble) 0.0 ;
9209 wxRect2D *result = 0 ;
9210 void *argp1 ;
9211 int res1 = 0 ;
9212 void *argp2 ;
9213 int res2 = 0 ;
9214 void *argp3 ;
9215 int res3 = 0 ;
9216 void *argp4 ;
9217 int res4 = 0 ;
9218 PyObject * obj0 = 0 ;
9219 PyObject * obj1 = 0 ;
9220 PyObject * obj2 = 0 ;
9221 PyObject * obj3 = 0 ;
9222 char * kwnames[] = {
9223 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9224 };
9225
9226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9227 if (obj0) {
9228 {
9229 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9230 if (!SWIG_IsOK(res1)) {
9231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9232 }
9233 if (!argp1) {
9234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9235 } else {
9236 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9237 arg1 = *temp;
9238 if (SWIG_IsNewObj(res1)) delete temp;
9239 }
9240 }
9241 }
9242 if (obj1) {
9243 {
9244 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9245 if (!SWIG_IsOK(res2)) {
9246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9247 }
9248 if (!argp2) {
9249 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9250 } else {
9251 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9252 arg2 = *temp;
9253 if (SWIG_IsNewObj(res2)) delete temp;
9254 }
9255 }
9256 }
9257 if (obj2) {
9258 {
9259 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9260 if (!SWIG_IsOK(res3)) {
9261 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9262 }
9263 if (!argp3) {
9264 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9265 } else {
9266 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9267 arg3 = *temp;
9268 if (SWIG_IsNewObj(res3)) delete temp;
9269 }
9270 }
9271 }
9272 if (obj3) {
9273 {
9274 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9275 if (!SWIG_IsOK(res4)) {
9276 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9277 }
9278 if (!argp4) {
9279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9280 } else {
9281 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9282 arg4 = *temp;
9283 if (SWIG_IsNewObj(res4)) delete temp;
9284 }
9285 }
9286 }
9287 {
9288 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9299 PyObject *resultobj = 0;
9300 wxRect2D *arg1 = (wxRect2D *) 0 ;
9301 void *argp1 = 0 ;
9302 int res1 = 0 ;
9303 PyObject *swig_obj[1] ;
9304
9305 if (!args) SWIG_fail;
9306 swig_obj[0] = args;
9307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9308 if (!SWIG_IsOK(res1)) {
9309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9310 }
9311 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9312 {
9313 delete arg1;
9314
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_Py_Void();
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9325 PyObject *resultobj = 0;
9326 wxRect2D *arg1 = (wxRect2D *) 0 ;
9327 wxPoint2D result;
9328 void *argp1 = 0 ;
9329 int res1 = 0 ;
9330 PyObject *swig_obj[1] ;
9331
9332 if (!args) SWIG_fail;
9333 swig_obj[0] = args;
9334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9337 }
9338 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9339 {
9340 result = (arg1)->GetPosition();
9341 if (PyErr_Occurred()) SWIG_fail;
9342 }
9343 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9344 return resultobj;
9345 fail:
9346 return NULL;
9347 }
9348
9349
9350 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9351 PyObject *resultobj = 0;
9352 wxRect2D *arg1 = (wxRect2D *) 0 ;
9353 wxSize result;
9354 void *argp1 = 0 ;
9355 int res1 = 0 ;
9356 PyObject *swig_obj[1] ;
9357
9358 if (!args) SWIG_fail;
9359 swig_obj[0] = args;
9360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9361 if (!SWIG_IsOK(res1)) {
9362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9363 }
9364 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9365 {
9366 result = (arg1)->GetSize();
9367 if (PyErr_Occurred()) SWIG_fail;
9368 }
9369 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9370 return resultobj;
9371 fail:
9372 return NULL;
9373 }
9374
9375
9376 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9377 PyObject *resultobj = 0;
9378 wxRect2D *arg1 = (wxRect2D *) 0 ;
9379 wxDouble result;
9380 void *argp1 = 0 ;
9381 int res1 = 0 ;
9382 PyObject *swig_obj[1] ;
9383
9384 if (!args) SWIG_fail;
9385 swig_obj[0] = args;
9386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9387 if (!SWIG_IsOK(res1)) {
9388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9389 }
9390 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9391 {
9392 result = ((wxRect2D const *)arg1)->GetLeft();
9393 if (PyErr_Occurred()) SWIG_fail;
9394 }
9395 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9396 return resultobj;
9397 fail:
9398 return NULL;
9399 }
9400
9401
9402 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9403 PyObject *resultobj = 0;
9404 wxRect2D *arg1 = (wxRect2D *) 0 ;
9405 wxDouble arg2 ;
9406 void *argp1 = 0 ;
9407 int res1 = 0 ;
9408 void *argp2 ;
9409 int res2 = 0 ;
9410 PyObject * obj0 = 0 ;
9411 PyObject * obj1 = 0 ;
9412 char * kwnames[] = {
9413 (char *) "self",(char *) "n", NULL
9414 };
9415
9416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9418 if (!SWIG_IsOK(res1)) {
9419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9420 }
9421 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9422 {
9423 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9424 if (!SWIG_IsOK(res2)) {
9425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9426 }
9427 if (!argp2) {
9428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9429 } else {
9430 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9431 arg2 = *temp;
9432 if (SWIG_IsNewObj(res2)) delete temp;
9433 }
9434 }
9435 {
9436 (arg1)->SetLeft(arg2);
9437 if (PyErr_Occurred()) SWIG_fail;
9438 }
9439 resultobj = SWIG_Py_Void();
9440 return resultobj;
9441 fail:
9442 return NULL;
9443 }
9444
9445
9446 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9447 PyObject *resultobj = 0;
9448 wxRect2D *arg1 = (wxRect2D *) 0 ;
9449 wxDouble arg2 ;
9450 void *argp1 = 0 ;
9451 int res1 = 0 ;
9452 void *argp2 ;
9453 int res2 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "n", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9464 }
9465 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9466 {
9467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9468 if (!SWIG_IsOK(res2)) {
9469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9470 }
9471 if (!argp2) {
9472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9473 } else {
9474 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9475 arg2 = *temp;
9476 if (SWIG_IsNewObj(res2)) delete temp;
9477 }
9478 }
9479 {
9480 (arg1)->MoveLeftTo(arg2);
9481 if (PyErr_Occurred()) SWIG_fail;
9482 }
9483 resultobj = SWIG_Py_Void();
9484 return resultobj;
9485 fail:
9486 return NULL;
9487 }
9488
9489
9490 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9491 PyObject *resultobj = 0;
9492 wxRect2D *arg1 = (wxRect2D *) 0 ;
9493 wxDouble result;
9494 void *argp1 = 0 ;
9495 int res1 = 0 ;
9496 PyObject *swig_obj[1] ;
9497
9498 if (!args) SWIG_fail;
9499 swig_obj[0] = args;
9500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9501 if (!SWIG_IsOK(res1)) {
9502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9503 }
9504 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9505 {
9506 result = ((wxRect2D const *)arg1)->GetTop();
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9517 PyObject *resultobj = 0;
9518 wxRect2D *arg1 = (wxRect2D *) 0 ;
9519 wxDouble arg2 ;
9520 void *argp1 = 0 ;
9521 int res1 = 0 ;
9522 void *argp2 ;
9523 int res2 = 0 ;
9524 PyObject * obj0 = 0 ;
9525 PyObject * obj1 = 0 ;
9526 char * kwnames[] = {
9527 (char *) "self",(char *) "n", NULL
9528 };
9529
9530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9532 if (!SWIG_IsOK(res1)) {
9533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9534 }
9535 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9536 {
9537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9538 if (!SWIG_IsOK(res2)) {
9539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9540 }
9541 if (!argp2) {
9542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9543 } else {
9544 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9545 arg2 = *temp;
9546 if (SWIG_IsNewObj(res2)) delete temp;
9547 }
9548 }
9549 {
9550 (arg1)->SetTop(arg2);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 resultobj = SWIG_Py_Void();
9554 return resultobj;
9555 fail:
9556 return NULL;
9557 }
9558
9559
9560 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9561 PyObject *resultobj = 0;
9562 wxRect2D *arg1 = (wxRect2D *) 0 ;
9563 wxDouble arg2 ;
9564 void *argp1 = 0 ;
9565 int res1 = 0 ;
9566 void *argp2 ;
9567 int res2 = 0 ;
9568 PyObject * obj0 = 0 ;
9569 PyObject * obj1 = 0 ;
9570 char * kwnames[] = {
9571 (char *) "self",(char *) "n", NULL
9572 };
9573
9574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9576 if (!SWIG_IsOK(res1)) {
9577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9578 }
9579 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9580 {
9581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9582 if (!SWIG_IsOK(res2)) {
9583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9584 }
9585 if (!argp2) {
9586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9587 } else {
9588 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9589 arg2 = *temp;
9590 if (SWIG_IsNewObj(res2)) delete temp;
9591 }
9592 }
9593 {
9594 (arg1)->MoveTopTo(arg2);
9595 if (PyErr_Occurred()) SWIG_fail;
9596 }
9597 resultobj = SWIG_Py_Void();
9598 return resultobj;
9599 fail:
9600 return NULL;
9601 }
9602
9603
9604 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9605 PyObject *resultobj = 0;
9606 wxRect2D *arg1 = (wxRect2D *) 0 ;
9607 wxDouble result;
9608 void *argp1 = 0 ;
9609 int res1 = 0 ;
9610 PyObject *swig_obj[1] ;
9611
9612 if (!args) SWIG_fail;
9613 swig_obj[0] = args;
9614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9615 if (!SWIG_IsOK(res1)) {
9616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9617 }
9618 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9619 {
9620 result = ((wxRect2D const *)arg1)->GetBottom();
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9624 return resultobj;
9625 fail:
9626 return NULL;
9627 }
9628
9629
9630 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9631 PyObject *resultobj = 0;
9632 wxRect2D *arg1 = (wxRect2D *) 0 ;
9633 wxDouble arg2 ;
9634 void *argp1 = 0 ;
9635 int res1 = 0 ;
9636 void *argp2 ;
9637 int res2 = 0 ;
9638 PyObject * obj0 = 0 ;
9639 PyObject * obj1 = 0 ;
9640 char * kwnames[] = {
9641 (char *) "self",(char *) "n", NULL
9642 };
9643
9644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9646 if (!SWIG_IsOK(res1)) {
9647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9648 }
9649 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9650 {
9651 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9652 if (!SWIG_IsOK(res2)) {
9653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9654 }
9655 if (!argp2) {
9656 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9657 } else {
9658 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9659 arg2 = *temp;
9660 if (SWIG_IsNewObj(res2)) delete temp;
9661 }
9662 }
9663 {
9664 (arg1)->SetBottom(arg2);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 resultobj = SWIG_Py_Void();
9668 return resultobj;
9669 fail:
9670 return NULL;
9671 }
9672
9673
9674 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9675 PyObject *resultobj = 0;
9676 wxRect2D *arg1 = (wxRect2D *) 0 ;
9677 wxDouble arg2 ;
9678 void *argp1 = 0 ;
9679 int res1 = 0 ;
9680 void *argp2 ;
9681 int res2 = 0 ;
9682 PyObject * obj0 = 0 ;
9683 PyObject * obj1 = 0 ;
9684 char * kwnames[] = {
9685 (char *) "self",(char *) "n", NULL
9686 };
9687
9688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9690 if (!SWIG_IsOK(res1)) {
9691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9692 }
9693 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9694 {
9695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9696 if (!SWIG_IsOK(res2)) {
9697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9698 }
9699 if (!argp2) {
9700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9701 } else {
9702 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9703 arg2 = *temp;
9704 if (SWIG_IsNewObj(res2)) delete temp;
9705 }
9706 }
9707 {
9708 (arg1)->MoveBottomTo(arg2);
9709 if (PyErr_Occurred()) SWIG_fail;
9710 }
9711 resultobj = SWIG_Py_Void();
9712 return resultobj;
9713 fail:
9714 return NULL;
9715 }
9716
9717
9718 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9719 PyObject *resultobj = 0;
9720 wxRect2D *arg1 = (wxRect2D *) 0 ;
9721 wxDouble result;
9722 void *argp1 = 0 ;
9723 int res1 = 0 ;
9724 PyObject *swig_obj[1] ;
9725
9726 if (!args) SWIG_fail;
9727 swig_obj[0] = args;
9728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9729 if (!SWIG_IsOK(res1)) {
9730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9731 }
9732 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9733 {
9734 result = ((wxRect2D const *)arg1)->GetRight();
9735 if (PyErr_Occurred()) SWIG_fail;
9736 }
9737 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9738 return resultobj;
9739 fail:
9740 return NULL;
9741 }
9742
9743
9744 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9745 PyObject *resultobj = 0;
9746 wxRect2D *arg1 = (wxRect2D *) 0 ;
9747 wxDouble arg2 ;
9748 void *argp1 = 0 ;
9749 int res1 = 0 ;
9750 void *argp2 ;
9751 int res2 = 0 ;
9752 PyObject * obj0 = 0 ;
9753 PyObject * obj1 = 0 ;
9754 char * kwnames[] = {
9755 (char *) "self",(char *) "n", NULL
9756 };
9757
9758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9760 if (!SWIG_IsOK(res1)) {
9761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9762 }
9763 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9764 {
9765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9766 if (!SWIG_IsOK(res2)) {
9767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9768 }
9769 if (!argp2) {
9770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9771 } else {
9772 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9773 arg2 = *temp;
9774 if (SWIG_IsNewObj(res2)) delete temp;
9775 }
9776 }
9777 {
9778 (arg1)->SetRight(arg2);
9779 if (PyErr_Occurred()) SWIG_fail;
9780 }
9781 resultobj = SWIG_Py_Void();
9782 return resultobj;
9783 fail:
9784 return NULL;
9785 }
9786
9787
9788 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9789 PyObject *resultobj = 0;
9790 wxRect2D *arg1 = (wxRect2D *) 0 ;
9791 wxDouble arg2 ;
9792 void *argp1 = 0 ;
9793 int res1 = 0 ;
9794 void *argp2 ;
9795 int res2 = 0 ;
9796 PyObject * obj0 = 0 ;
9797 PyObject * obj1 = 0 ;
9798 char * kwnames[] = {
9799 (char *) "self",(char *) "n", NULL
9800 };
9801
9802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9804 if (!SWIG_IsOK(res1)) {
9805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9806 }
9807 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9808 {
9809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9810 if (!SWIG_IsOK(res2)) {
9811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9812 }
9813 if (!argp2) {
9814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9815 } else {
9816 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9817 arg2 = *temp;
9818 if (SWIG_IsNewObj(res2)) delete temp;
9819 }
9820 }
9821 {
9822 (arg1)->MoveRightTo(arg2);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 resultobj = SWIG_Py_Void();
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9833 PyObject *resultobj = 0;
9834 wxRect2D *arg1 = (wxRect2D *) 0 ;
9835 wxPoint2D result;
9836 void *argp1 = 0 ;
9837 int res1 = 0 ;
9838 PyObject *swig_obj[1] ;
9839
9840 if (!args) SWIG_fail;
9841 swig_obj[0] = args;
9842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9843 if (!SWIG_IsOK(res1)) {
9844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9845 }
9846 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9847 {
9848 result = ((wxRect2D const *)arg1)->GetLeftTop();
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9859 PyObject *resultobj = 0;
9860 wxRect2D *arg1 = (wxRect2D *) 0 ;
9861 wxPoint2D *arg2 = 0 ;
9862 void *argp1 = 0 ;
9863 int res1 = 0 ;
9864 wxPoint2D temp2 ;
9865 PyObject * obj0 = 0 ;
9866 PyObject * obj1 = 0 ;
9867 char * kwnames[] = {
9868 (char *) "self",(char *) "pt", NULL
9869 };
9870
9871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9873 if (!SWIG_IsOK(res1)) {
9874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9875 }
9876 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9877 {
9878 arg2 = &temp2;
9879 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9880 }
9881 {
9882 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9883 if (PyErr_Occurred()) SWIG_fail;
9884 }
9885 resultobj = SWIG_Py_Void();
9886 return resultobj;
9887 fail:
9888 return NULL;
9889 }
9890
9891
9892 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj = 0;
9894 wxRect2D *arg1 = (wxRect2D *) 0 ;
9895 wxPoint2D *arg2 = 0 ;
9896 void *argp1 = 0 ;
9897 int res1 = 0 ;
9898 wxPoint2D temp2 ;
9899 PyObject * obj0 = 0 ;
9900 PyObject * obj1 = 0 ;
9901 char * kwnames[] = {
9902 (char *) "self",(char *) "pt", NULL
9903 };
9904
9905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9909 }
9910 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9911 {
9912 arg2 = &temp2;
9913 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9914 }
9915 {
9916 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 resultobj = SWIG_Py_Void();
9920 return resultobj;
9921 fail:
9922 return NULL;
9923 }
9924
9925
9926 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9927 PyObject *resultobj = 0;
9928 wxRect2D *arg1 = (wxRect2D *) 0 ;
9929 wxPoint2D result;
9930 void *argp1 = 0 ;
9931 int res1 = 0 ;
9932 PyObject *swig_obj[1] ;
9933
9934 if (!args) SWIG_fail;
9935 swig_obj[0] = args;
9936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9937 if (!SWIG_IsOK(res1)) {
9938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9939 }
9940 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9941 {
9942 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9943 if (PyErr_Occurred()) SWIG_fail;
9944 }
9945 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9946 return resultobj;
9947 fail:
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxRect2D *arg1 = (wxRect2D *) 0 ;
9955 wxPoint2D *arg2 = 0 ;
9956 void *argp1 = 0 ;
9957 int res1 = 0 ;
9958 wxPoint2D temp2 ;
9959 PyObject * obj0 = 0 ;
9960 PyObject * obj1 = 0 ;
9961 char * kwnames[] = {
9962 (char *) "self",(char *) "pt", NULL
9963 };
9964
9965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9967 if (!SWIG_IsOK(res1)) {
9968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9969 }
9970 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9971 {
9972 arg2 = &temp2;
9973 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9974 }
9975 {
9976 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9977 if (PyErr_Occurred()) SWIG_fail;
9978 }
9979 resultobj = SWIG_Py_Void();
9980 return resultobj;
9981 fail:
9982 return NULL;
9983 }
9984
9985
9986 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9987 PyObject *resultobj = 0;
9988 wxRect2D *arg1 = (wxRect2D *) 0 ;
9989 wxPoint2D *arg2 = 0 ;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 wxPoint2D temp2 ;
9993 PyObject * obj0 = 0 ;
9994 PyObject * obj1 = 0 ;
9995 char * kwnames[] = {
9996 (char *) "self",(char *) "pt", NULL
9997 };
9998
9999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10001 if (!SWIG_IsOK(res1)) {
10002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10003 }
10004 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10005 {
10006 arg2 = &temp2;
10007 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10008 }
10009 {
10010 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 resultobj = SWIG_Py_Void();
10014 return resultobj;
10015 fail:
10016 return NULL;
10017 }
10018
10019
10020 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 PyObject *resultobj = 0;
10022 wxRect2D *arg1 = (wxRect2D *) 0 ;
10023 wxPoint2D result;
10024 void *argp1 = 0 ;
10025 int res1 = 0 ;
10026 PyObject *swig_obj[1] ;
10027
10028 if (!args) SWIG_fail;
10029 swig_obj[0] = args;
10030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10031 if (!SWIG_IsOK(res1)) {
10032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10033 }
10034 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10035 {
10036 result = ((wxRect2D const *)arg1)->GetRightTop();
10037 if (PyErr_Occurred()) SWIG_fail;
10038 }
10039 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10040 return resultobj;
10041 fail:
10042 return NULL;
10043 }
10044
10045
10046 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10047 PyObject *resultobj = 0;
10048 wxRect2D *arg1 = (wxRect2D *) 0 ;
10049 wxPoint2D *arg2 = 0 ;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 wxPoint2D temp2 ;
10053 PyObject * obj0 = 0 ;
10054 PyObject * obj1 = 0 ;
10055 char * kwnames[] = {
10056 (char *) "self",(char *) "pt", NULL
10057 };
10058
10059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10061 if (!SWIG_IsOK(res1)) {
10062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10063 }
10064 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10065 {
10066 arg2 = &temp2;
10067 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10068 }
10069 {
10070 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10071 if (PyErr_Occurred()) SWIG_fail;
10072 }
10073 resultobj = SWIG_Py_Void();
10074 return resultobj;
10075 fail:
10076 return NULL;
10077 }
10078
10079
10080 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj = 0;
10082 wxRect2D *arg1 = (wxRect2D *) 0 ;
10083 wxPoint2D *arg2 = 0 ;
10084 void *argp1 = 0 ;
10085 int res1 = 0 ;
10086 wxPoint2D temp2 ;
10087 PyObject * obj0 = 0 ;
10088 PyObject * obj1 = 0 ;
10089 char * kwnames[] = {
10090 (char *) "self",(char *) "pt", NULL
10091 };
10092
10093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10095 if (!SWIG_IsOK(res1)) {
10096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10097 }
10098 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10099 {
10100 arg2 = &temp2;
10101 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10102 }
10103 {
10104 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10105 if (PyErr_Occurred()) SWIG_fail;
10106 }
10107 resultobj = SWIG_Py_Void();
10108 return resultobj;
10109 fail:
10110 return NULL;
10111 }
10112
10113
10114 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10115 PyObject *resultobj = 0;
10116 wxRect2D *arg1 = (wxRect2D *) 0 ;
10117 wxPoint2D result;
10118 void *argp1 = 0 ;
10119 int res1 = 0 ;
10120 PyObject *swig_obj[1] ;
10121
10122 if (!args) SWIG_fail;
10123 swig_obj[0] = args;
10124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10125 if (!SWIG_IsOK(res1)) {
10126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10127 }
10128 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10129 {
10130 result = ((wxRect2D const *)arg1)->GetRightBottom();
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10134 return resultobj;
10135 fail:
10136 return NULL;
10137 }
10138
10139
10140 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10141 PyObject *resultobj = 0;
10142 wxRect2D *arg1 = (wxRect2D *) 0 ;
10143 wxPoint2D *arg2 = 0 ;
10144 void *argp1 = 0 ;
10145 int res1 = 0 ;
10146 wxPoint2D temp2 ;
10147 PyObject * obj0 = 0 ;
10148 PyObject * obj1 = 0 ;
10149 char * kwnames[] = {
10150 (char *) "self",(char *) "pt", NULL
10151 };
10152
10153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10157 }
10158 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10159 {
10160 arg2 = &temp2;
10161 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10162 }
10163 {
10164 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10165 if (PyErr_Occurred()) SWIG_fail;
10166 }
10167 resultobj = SWIG_Py_Void();
10168 return resultobj;
10169 fail:
10170 return NULL;
10171 }
10172
10173
10174 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10175 PyObject *resultobj = 0;
10176 wxRect2D *arg1 = (wxRect2D *) 0 ;
10177 wxPoint2D *arg2 = 0 ;
10178 void *argp1 = 0 ;
10179 int res1 = 0 ;
10180 wxPoint2D temp2 ;
10181 PyObject * obj0 = 0 ;
10182 PyObject * obj1 = 0 ;
10183 char * kwnames[] = {
10184 (char *) "self",(char *) "pt", NULL
10185 };
10186
10187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10189 if (!SWIG_IsOK(res1)) {
10190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10191 }
10192 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10193 {
10194 arg2 = &temp2;
10195 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10196 }
10197 {
10198 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 resultobj = SWIG_Py_Void();
10202 return resultobj;
10203 fail:
10204 return NULL;
10205 }
10206
10207
10208 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10209 PyObject *resultobj = 0;
10210 wxRect2D *arg1 = (wxRect2D *) 0 ;
10211 wxPoint2D result;
10212 void *argp1 = 0 ;
10213 int res1 = 0 ;
10214 PyObject *swig_obj[1] ;
10215
10216 if (!args) SWIG_fail;
10217 swig_obj[0] = args;
10218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10219 if (!SWIG_IsOK(res1)) {
10220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10221 }
10222 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10223 {
10224 result = ((wxRect2D const *)arg1)->GetCentre();
10225 if (PyErr_Occurred()) SWIG_fail;
10226 }
10227 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10228 return resultobj;
10229 fail:
10230 return NULL;
10231 }
10232
10233
10234 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj = 0;
10236 wxRect2D *arg1 = (wxRect2D *) 0 ;
10237 wxPoint2D *arg2 = 0 ;
10238 void *argp1 = 0 ;
10239 int res1 = 0 ;
10240 wxPoint2D temp2 ;
10241 PyObject * obj0 = 0 ;
10242 PyObject * obj1 = 0 ;
10243 char * kwnames[] = {
10244 (char *) "self",(char *) "pt", NULL
10245 };
10246
10247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10249 if (!SWIG_IsOK(res1)) {
10250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10251 }
10252 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10253 {
10254 arg2 = &temp2;
10255 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10256 }
10257 {
10258 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 resultobj = SWIG_Py_Void();
10262 return resultobj;
10263 fail:
10264 return NULL;
10265 }
10266
10267
10268 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10269 PyObject *resultobj = 0;
10270 wxRect2D *arg1 = (wxRect2D *) 0 ;
10271 wxPoint2D *arg2 = 0 ;
10272 void *argp1 = 0 ;
10273 int res1 = 0 ;
10274 wxPoint2D temp2 ;
10275 PyObject * obj0 = 0 ;
10276 PyObject * obj1 = 0 ;
10277 char * kwnames[] = {
10278 (char *) "self",(char *) "pt", NULL
10279 };
10280
10281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10283 if (!SWIG_IsOK(res1)) {
10284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10285 }
10286 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10287 {
10288 arg2 = &temp2;
10289 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10290 }
10291 {
10292 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10293 if (PyErr_Occurred()) SWIG_fail;
10294 }
10295 resultobj = SWIG_Py_Void();
10296 return resultobj;
10297 fail:
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj = 0;
10304 wxRect2D *arg1 = (wxRect2D *) 0 ;
10305 wxPoint2D *arg2 = 0 ;
10306 wxOutCode result;
10307 void *argp1 = 0 ;
10308 int res1 = 0 ;
10309 wxPoint2D temp2 ;
10310 PyObject * obj0 = 0 ;
10311 PyObject * obj1 = 0 ;
10312 char * kwnames[] = {
10313 (char *) "self",(char *) "pt", NULL
10314 };
10315
10316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10318 if (!SWIG_IsOK(res1)) {
10319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10320 }
10321 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10322 {
10323 arg2 = &temp2;
10324 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10325 }
10326 {
10327 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10328 if (PyErr_Occurred()) SWIG_fail;
10329 }
10330 resultobj = SWIG_From_int(static_cast< int >(result));
10331 return resultobj;
10332 fail:
10333 return NULL;
10334 }
10335
10336
10337 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10338 PyObject *resultobj = 0;
10339 wxRect2D *arg1 = (wxRect2D *) 0 ;
10340 wxPoint2D *arg2 = 0 ;
10341 bool result;
10342 void *argp1 = 0 ;
10343 int res1 = 0 ;
10344 wxPoint2D temp2 ;
10345 PyObject * obj0 = 0 ;
10346 PyObject * obj1 = 0 ;
10347 char * kwnames[] = {
10348 (char *) "self",(char *) "pt", NULL
10349 };
10350
10351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10353 if (!SWIG_IsOK(res1)) {
10354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10355 }
10356 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10357 {
10358 arg2 = &temp2;
10359 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10360 }
10361 {
10362 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 {
10366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10367 }
10368 return resultobj;
10369 fail:
10370 return NULL;
10371 }
10372
10373
10374 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10375 PyObject *resultobj = 0;
10376 wxRect2D *arg1 = (wxRect2D *) 0 ;
10377 wxRect2D *arg2 = 0 ;
10378 bool result;
10379 void *argp1 = 0 ;
10380 int res1 = 0 ;
10381 wxRect2D temp2 ;
10382 PyObject * obj0 = 0 ;
10383 PyObject * obj1 = 0 ;
10384 char * kwnames[] = {
10385 (char *) "self",(char *) "rect", NULL
10386 };
10387
10388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10390 if (!SWIG_IsOK(res1)) {
10391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10392 }
10393 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10394 {
10395 arg2 = &temp2;
10396 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10397 }
10398 {
10399 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10400 if (PyErr_Occurred()) SWIG_fail;
10401 }
10402 {
10403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10404 }
10405 return resultobj;
10406 fail:
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10412 PyObject *resultobj = 0;
10413 wxRect2D *arg1 = (wxRect2D *) 0 ;
10414 bool result;
10415 void *argp1 = 0 ;
10416 int res1 = 0 ;
10417 PyObject *swig_obj[1] ;
10418
10419 if (!args) SWIG_fail;
10420 swig_obj[0] = args;
10421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10422 if (!SWIG_IsOK(res1)) {
10423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10424 }
10425 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10426 {
10427 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10428 if (PyErr_Occurred()) SWIG_fail;
10429 }
10430 {
10431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10432 }
10433 return resultobj;
10434 fail:
10435 return NULL;
10436 }
10437
10438
10439 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10440 PyObject *resultobj = 0;
10441 wxRect2D *arg1 = (wxRect2D *) 0 ;
10442 wxRect2D *arg2 = 0 ;
10443 bool result;
10444 void *argp1 = 0 ;
10445 int res1 = 0 ;
10446 wxRect2D temp2 ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449 char * kwnames[] = {
10450 (char *) "self",(char *) "rect", NULL
10451 };
10452
10453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10455 if (!SWIG_IsOK(res1)) {
10456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10457 }
10458 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10459 {
10460 arg2 = &temp2;
10461 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10462 }
10463 {
10464 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10465 if (PyErr_Occurred()) SWIG_fail;
10466 }
10467 {
10468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10469 }
10470 return resultobj;
10471 fail:
10472 return NULL;
10473 }
10474
10475
10476 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10477 PyObject *resultobj = 0;
10478 wxRect2D *arg1 = (wxRect2D *) 0 ;
10479 wxDouble arg2 ;
10480 wxDouble arg3 ;
10481 void *argp1 = 0 ;
10482 int res1 = 0 ;
10483 void *argp2 ;
10484 int res2 = 0 ;
10485 void *argp3 ;
10486 int res3 = 0 ;
10487
10488 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10490 if (!SWIG_IsOK(res1)) {
10491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10492 }
10493 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10494 {
10495 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10496 if (!SWIG_IsOK(res2)) {
10497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10498 }
10499 if (!argp2) {
10500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10501 } else {
10502 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10503 arg2 = *temp;
10504 if (SWIG_IsNewObj(res2)) delete temp;
10505 }
10506 }
10507 {
10508 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10509 if (!SWIG_IsOK(res3)) {
10510 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10511 }
10512 if (!argp3) {
10513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10514 } else {
10515 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10516 arg3 = *temp;
10517 if (SWIG_IsNewObj(res3)) delete temp;
10518 }
10519 }
10520 {
10521 (arg1)->Inset(arg2,arg3);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 resultobj = SWIG_Py_Void();
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10532 PyObject *resultobj = 0;
10533 wxRect2D *arg1 = (wxRect2D *) 0 ;
10534 wxDouble arg2 ;
10535 wxDouble arg3 ;
10536 wxDouble arg4 ;
10537 wxDouble arg5 ;
10538 void *argp1 = 0 ;
10539 int res1 = 0 ;
10540 void *argp2 ;
10541 int res2 = 0 ;
10542 void *argp3 ;
10543 int res3 = 0 ;
10544 void *argp4 ;
10545 int res4 = 0 ;
10546 void *argp5 ;
10547 int res5 = 0 ;
10548
10549 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10551 if (!SWIG_IsOK(res1)) {
10552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10553 }
10554 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10555 {
10556 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10557 if (!SWIG_IsOK(res2)) {
10558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10559 }
10560 if (!argp2) {
10561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10562 } else {
10563 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10564 arg2 = *temp;
10565 if (SWIG_IsNewObj(res2)) delete temp;
10566 }
10567 }
10568 {
10569 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10570 if (!SWIG_IsOK(res3)) {
10571 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10572 }
10573 if (!argp3) {
10574 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10575 } else {
10576 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10577 arg3 = *temp;
10578 if (SWIG_IsNewObj(res3)) delete temp;
10579 }
10580 }
10581 {
10582 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10583 if (!SWIG_IsOK(res4)) {
10584 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10585 }
10586 if (!argp4) {
10587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10588 } else {
10589 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10590 arg4 = *temp;
10591 if (SWIG_IsNewObj(res4)) delete temp;
10592 }
10593 }
10594 {
10595 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10596 if (!SWIG_IsOK(res5)) {
10597 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10598 }
10599 if (!argp5) {
10600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10601 } else {
10602 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10603 arg5 = *temp;
10604 if (SWIG_IsNewObj(res5)) delete temp;
10605 }
10606 }
10607 {
10608 (arg1)->Inset(arg2,arg3,arg4,arg5);
10609 if (PyErr_Occurred()) SWIG_fail;
10610 }
10611 resultobj = SWIG_Py_Void();
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10619 int argc;
10620 PyObject *argv[6];
10621
10622 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10623 --argc;
10624 if (argc == 3) {
10625 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10626 }
10627 if (argc == 5) {
10628 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10629 }
10630
10631 fail:
10632 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10633 return NULL;
10634 }
10635
10636
10637 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10638 PyObject *resultobj = 0;
10639 wxRect2D *arg1 = (wxRect2D *) 0 ;
10640 wxPoint2D *arg2 = 0 ;
10641 void *argp1 = 0 ;
10642 int res1 = 0 ;
10643 wxPoint2D temp2 ;
10644 PyObject * obj0 = 0 ;
10645 PyObject * obj1 = 0 ;
10646 char * kwnames[] = {
10647 (char *) "self",(char *) "pt", NULL
10648 };
10649
10650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10652 if (!SWIG_IsOK(res1)) {
10653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10654 }
10655 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10656 {
10657 arg2 = &temp2;
10658 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10659 }
10660 {
10661 (arg1)->Offset((wxPoint2D const &)*arg2);
10662 if (PyErr_Occurred()) SWIG_fail;
10663 }
10664 resultobj = SWIG_Py_Void();
10665 return resultobj;
10666 fail:
10667 return NULL;
10668 }
10669
10670
10671 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10672 PyObject *resultobj = 0;
10673 wxRect2D *arg1 = (wxRect2D *) 0 ;
10674 wxRect2D *arg2 = 0 ;
10675 void *argp1 = 0 ;
10676 int res1 = 0 ;
10677 wxRect2D temp2 ;
10678 PyObject * obj0 = 0 ;
10679 PyObject * obj1 = 0 ;
10680 char * kwnames[] = {
10681 (char *) "self",(char *) "rect", NULL
10682 };
10683
10684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10686 if (!SWIG_IsOK(res1)) {
10687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10688 }
10689 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10690 {
10691 arg2 = &temp2;
10692 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10693 }
10694 {
10695 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10696 if (PyErr_Occurred()) SWIG_fail;
10697 }
10698 resultobj = SWIG_Py_Void();
10699 return resultobj;
10700 fail:
10701 return NULL;
10702 }
10703
10704
10705 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10706 PyObject *resultobj = 0;
10707 wxRect2D *arg1 = (wxRect2D *) 0 ;
10708 int arg2 ;
10709 int arg3 ;
10710 wxPoint2D result;
10711 void *argp1 = 0 ;
10712 int res1 = 0 ;
10713 int val2 ;
10714 int ecode2 = 0 ;
10715 int val3 ;
10716 int ecode3 = 0 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 PyObject * obj2 = 0 ;
10720 char * kwnames[] = {
10721 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10722 };
10723
10724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10726 if (!SWIG_IsOK(res1)) {
10727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10728 }
10729 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10730 ecode2 = SWIG_AsVal_int(obj1, &val2);
10731 if (!SWIG_IsOK(ecode2)) {
10732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10733 }
10734 arg2 = static_cast< int >(val2);
10735 ecode3 = SWIG_AsVal_int(obj2, &val3);
10736 if (!SWIG_IsOK(ecode3)) {
10737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10738 }
10739 arg3 = static_cast< int >(val3);
10740 {
10741 result = (arg1)->Interpolate(arg2,arg3);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10745 return resultobj;
10746 fail:
10747 return NULL;
10748 }
10749
10750
10751 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10752 PyObject *resultobj = 0;
10753 wxRect2D *arg1 = (wxRect2D *) 0 ;
10754 wxRect2D *arg2 = 0 ;
10755 void *argp1 = 0 ;
10756 int res1 = 0 ;
10757 wxRect2D temp2 ;
10758 PyObject * obj0 = 0 ;
10759 PyObject * obj1 = 0 ;
10760 char * kwnames[] = {
10761 (char *) "self",(char *) "otherRect", NULL
10762 };
10763
10764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10766 if (!SWIG_IsOK(res1)) {
10767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10768 }
10769 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10770 {
10771 arg2 = &temp2;
10772 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10773 }
10774 {
10775 (arg1)->Intersect((wxRect2D const &)*arg2);
10776 if (PyErr_Occurred()) SWIG_fail;
10777 }
10778 resultobj = SWIG_Py_Void();
10779 return resultobj;
10780 fail:
10781 return NULL;
10782 }
10783
10784
10785 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10786 PyObject *resultobj = 0;
10787 wxRect2D *arg1 = (wxRect2D *) 0 ;
10788 wxRect2D *arg2 = 0 ;
10789 wxRect2D result;
10790 void *argp1 = 0 ;
10791 int res1 = 0 ;
10792 wxRect2D temp2 ;
10793 PyObject * obj0 = 0 ;
10794 PyObject * obj1 = 0 ;
10795 char * kwnames[] = {
10796 (char *) "self",(char *) "otherRect", NULL
10797 };
10798
10799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10801 if (!SWIG_IsOK(res1)) {
10802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10803 }
10804 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10805 {
10806 arg2 = &temp2;
10807 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10808 }
10809 {
10810 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj = 0;
10822 wxRect2D *arg1 = (wxRect2D *) 0 ;
10823 wxRect2D *arg2 = 0 ;
10824 bool result;
10825 void *argp1 = 0 ;
10826 int res1 = 0 ;
10827 wxRect2D temp2 ;
10828 PyObject * obj0 = 0 ;
10829 PyObject * obj1 = 0 ;
10830 char * kwnames[] = {
10831 (char *) "self",(char *) "rect", NULL
10832 };
10833
10834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10836 if (!SWIG_IsOK(res1)) {
10837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10838 }
10839 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10840 {
10841 arg2 = &temp2;
10842 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10843 }
10844 {
10845 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 {
10849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10850 }
10851 return resultobj;
10852 fail:
10853 return NULL;
10854 }
10855
10856
10857 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10858 PyObject *resultobj = 0;
10859 wxRect2D *arg1 = (wxRect2D *) 0 ;
10860 wxRect2D *arg2 = 0 ;
10861 void *argp1 = 0 ;
10862 int res1 = 0 ;
10863 wxRect2D temp2 ;
10864 PyObject * obj0 = 0 ;
10865 PyObject * obj1 = 0 ;
10866 char * kwnames[] = {
10867 (char *) "self",(char *) "otherRect", NULL
10868 };
10869
10870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10874 }
10875 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10876 {
10877 arg2 = &temp2;
10878 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10879 }
10880 {
10881 (arg1)->Union((wxRect2D const &)*arg2);
10882 if (PyErr_Occurred()) SWIG_fail;
10883 }
10884 resultobj = SWIG_Py_Void();
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj = 0;
10893 wxRect2D *arg1 = (wxRect2D *) 0 ;
10894 wxRect2D *arg2 = 0 ;
10895 wxRect2D result;
10896 void *argp1 = 0 ;
10897 int res1 = 0 ;
10898 wxRect2D temp2 ;
10899 PyObject * obj0 = 0 ;
10900 PyObject * obj1 = 0 ;
10901 char * kwnames[] = {
10902 (char *) "self",(char *) "otherRect", NULL
10903 };
10904
10905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10909 }
10910 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10911 {
10912 arg2 = &temp2;
10913 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10914 }
10915 {
10916 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10917 if (PyErr_Occurred()) SWIG_fail;
10918 }
10919 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10920 return resultobj;
10921 fail:
10922 return NULL;
10923 }
10924
10925
10926 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10927 PyObject *resultobj = 0;
10928 wxRect2D *arg1 = (wxRect2D *) 0 ;
10929 wxDouble arg2 ;
10930 void *argp1 = 0 ;
10931 int res1 = 0 ;
10932 void *argp2 ;
10933 int res2 = 0 ;
10934
10935 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10937 if (!SWIG_IsOK(res1)) {
10938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10939 }
10940 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10941 {
10942 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10943 if (!SWIG_IsOK(res2)) {
10944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10945 }
10946 if (!argp2) {
10947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10948 } else {
10949 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10950 arg2 = *temp;
10951 if (SWIG_IsNewObj(res2)) delete temp;
10952 }
10953 }
10954 {
10955 (arg1)->Scale(arg2);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 resultobj = SWIG_Py_Void();
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10966 PyObject *resultobj = 0;
10967 wxRect2D *arg1 = (wxRect2D *) 0 ;
10968 int arg2 ;
10969 int arg3 ;
10970 void *argp1 = 0 ;
10971 int res1 = 0 ;
10972 int val2 ;
10973 int ecode2 = 0 ;
10974 int val3 ;
10975 int ecode3 = 0 ;
10976
10977 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10979 if (!SWIG_IsOK(res1)) {
10980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10981 }
10982 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10983 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10984 if (!SWIG_IsOK(ecode2)) {
10985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10986 }
10987 arg2 = static_cast< int >(val2);
10988 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10989 if (!SWIG_IsOK(ecode3)) {
10990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10991 }
10992 arg3 = static_cast< int >(val3);
10993 {
10994 (arg1)->Scale(arg2,arg3);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 resultobj = SWIG_Py_Void();
10998 return resultobj;
10999 fail:
11000 return NULL;
11001 }
11002
11003
11004 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11005 int argc;
11006 PyObject *argv[4];
11007
11008 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11009 --argc;
11010 if (argc == 2) {
11011 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11012 }
11013 if (argc == 3) {
11014 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11015 }
11016
11017 fail:
11018 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11019 return NULL;
11020 }
11021
11022
11023 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj = 0;
11025 wxRect2D *arg1 = (wxRect2D *) 0 ;
11026 PyObject *arg2 = (PyObject *) 0 ;
11027 bool result;
11028 void *argp1 = 0 ;
11029 int res1 = 0 ;
11030 PyObject * obj0 = 0 ;
11031 PyObject * obj1 = 0 ;
11032 char * kwnames[] = {
11033 (char *) "self",(char *) "other", NULL
11034 };
11035
11036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11038 if (!SWIG_IsOK(res1)) {
11039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11040 }
11041 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11042 arg2 = obj1;
11043 {
11044 result = (bool)wxRect2D___eq__(arg1,arg2);
11045 if (PyErr_Occurred()) SWIG_fail;
11046 }
11047 {
11048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj = 0;
11058 wxRect2D *arg1 = (wxRect2D *) 0 ;
11059 PyObject *arg2 = (PyObject *) 0 ;
11060 bool result;
11061 void *argp1 = 0 ;
11062 int res1 = 0 ;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065 char * kwnames[] = {
11066 (char *) "self",(char *) "other", NULL
11067 };
11068
11069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11071 if (!SWIG_IsOK(res1)) {
11072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11073 }
11074 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11075 arg2 = obj1;
11076 {
11077 result = (bool)wxRect2D___ne__(arg1,arg2);
11078 if (PyErr_Occurred()) SWIG_fail;
11079 }
11080 {
11081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11082 }
11083 return resultobj;
11084 fail:
11085 return NULL;
11086 }
11087
11088
11089 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11090 PyObject *resultobj = 0;
11091 wxRect2D *arg1 = (wxRect2D *) 0 ;
11092 wxDouble arg2 ;
11093 void *argp1 = 0 ;
11094 int res1 = 0 ;
11095 void *argp2 ;
11096 int res2 = 0 ;
11097 PyObject *swig_obj[2] ;
11098
11099 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11101 if (!SWIG_IsOK(res1)) {
11102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11103 }
11104 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11105 {
11106 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11107 if (!SWIG_IsOK(res2)) {
11108 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11109 }
11110 if (!argp2) {
11111 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11112 } else {
11113 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11114 arg2 = *temp;
11115 if (SWIG_IsNewObj(res2)) delete temp;
11116 }
11117 }
11118 if (arg1) (arg1)->m_x = arg2;
11119
11120 resultobj = SWIG_Py_Void();
11121 return resultobj;
11122 fail:
11123 return NULL;
11124 }
11125
11126
11127 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11128 PyObject *resultobj = 0;
11129 wxRect2D *arg1 = (wxRect2D *) 0 ;
11130 wxDouble result;
11131 void *argp1 = 0 ;
11132 int res1 = 0 ;
11133 PyObject *swig_obj[1] ;
11134
11135 if (!args) SWIG_fail;
11136 swig_obj[0] = args;
11137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11138 if (!SWIG_IsOK(res1)) {
11139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11140 }
11141 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11142 result = ((arg1)->m_x);
11143 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11151 PyObject *resultobj = 0;
11152 wxRect2D *arg1 = (wxRect2D *) 0 ;
11153 wxDouble arg2 ;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 void *argp2 ;
11157 int res2 = 0 ;
11158 PyObject *swig_obj[2] ;
11159
11160 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11162 if (!SWIG_IsOK(res1)) {
11163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11164 }
11165 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11166 {
11167 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11168 if (!SWIG_IsOK(res2)) {
11169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11170 }
11171 if (!argp2) {
11172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11173 } else {
11174 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11175 arg2 = *temp;
11176 if (SWIG_IsNewObj(res2)) delete temp;
11177 }
11178 }
11179 if (arg1) (arg1)->m_y = arg2;
11180
11181 resultobj = SWIG_Py_Void();
11182 return resultobj;
11183 fail:
11184 return NULL;
11185 }
11186
11187
11188 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11189 PyObject *resultobj = 0;
11190 wxRect2D *arg1 = (wxRect2D *) 0 ;
11191 wxDouble result;
11192 void *argp1 = 0 ;
11193 int res1 = 0 ;
11194 PyObject *swig_obj[1] ;
11195
11196 if (!args) SWIG_fail;
11197 swig_obj[0] = args;
11198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11199 if (!SWIG_IsOK(res1)) {
11200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11201 }
11202 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11203 result = ((arg1)->m_y);
11204 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213 wxRect2D *arg1 = (wxRect2D *) 0 ;
11214 wxDouble arg2 ;
11215 void *argp1 = 0 ;
11216 int res1 = 0 ;
11217 void *argp2 ;
11218 int res2 = 0 ;
11219 PyObject *swig_obj[2] ;
11220
11221 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11223 if (!SWIG_IsOK(res1)) {
11224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11225 }
11226 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11227 {
11228 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11229 if (!SWIG_IsOK(res2)) {
11230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11231 }
11232 if (!argp2) {
11233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11234 } else {
11235 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11236 arg2 = *temp;
11237 if (SWIG_IsNewObj(res2)) delete temp;
11238 }
11239 }
11240 if (arg1) (arg1)->m_width = arg2;
11241
11242 resultobj = SWIG_Py_Void();
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11250 PyObject *resultobj = 0;
11251 wxRect2D *arg1 = (wxRect2D *) 0 ;
11252 wxDouble result;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 PyObject *swig_obj[1] ;
11256
11257 if (!args) SWIG_fail;
11258 swig_obj[0] = args;
11259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11260 if (!SWIG_IsOK(res1)) {
11261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11262 }
11263 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11264 result = ((arg1)->m_width);
11265 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11273 PyObject *resultobj = 0;
11274 wxRect2D *arg1 = (wxRect2D *) 0 ;
11275 wxDouble arg2 ;
11276 void *argp1 = 0 ;
11277 int res1 = 0 ;
11278 void *argp2 ;
11279 int res2 = 0 ;
11280 PyObject *swig_obj[2] ;
11281
11282 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11284 if (!SWIG_IsOK(res1)) {
11285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11286 }
11287 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11288 {
11289 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11290 if (!SWIG_IsOK(res2)) {
11291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11292 }
11293 if (!argp2) {
11294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11295 } else {
11296 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11297 arg2 = *temp;
11298 if (SWIG_IsNewObj(res2)) delete temp;
11299 }
11300 }
11301 if (arg1) (arg1)->m_height = arg2;
11302
11303 resultobj = SWIG_Py_Void();
11304 return resultobj;
11305 fail:
11306 return NULL;
11307 }
11308
11309
11310 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11311 PyObject *resultobj = 0;
11312 wxRect2D *arg1 = (wxRect2D *) 0 ;
11313 wxDouble result;
11314 void *argp1 = 0 ;
11315 int res1 = 0 ;
11316 PyObject *swig_obj[1] ;
11317
11318 if (!args) SWIG_fail;
11319 swig_obj[0] = args;
11320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11321 if (!SWIG_IsOK(res1)) {
11322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11323 }
11324 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11325 result = ((arg1)->m_height);
11326 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11334 PyObject *resultobj = 0;
11335 wxRect2D *arg1 = (wxRect2D *) 0 ;
11336 wxDouble arg2 = (wxDouble) 0 ;
11337 wxDouble arg3 = (wxDouble) 0 ;
11338 wxDouble arg4 = (wxDouble) 0 ;
11339 wxDouble arg5 = (wxDouble) 0 ;
11340 void *argp1 = 0 ;
11341 int res1 = 0 ;
11342 void *argp2 ;
11343 int res2 = 0 ;
11344 void *argp3 ;
11345 int res3 = 0 ;
11346 void *argp4 ;
11347 int res4 = 0 ;
11348 void *argp5 ;
11349 int res5 = 0 ;
11350 PyObject * obj0 = 0 ;
11351 PyObject * obj1 = 0 ;
11352 PyObject * obj2 = 0 ;
11353 PyObject * obj3 = 0 ;
11354 PyObject * obj4 = 0 ;
11355 char * kwnames[] = {
11356 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11357 };
11358
11359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11361 if (!SWIG_IsOK(res1)) {
11362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11363 }
11364 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11365 if (obj1) {
11366 {
11367 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11368 if (!SWIG_IsOK(res2)) {
11369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11370 }
11371 if (!argp2) {
11372 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11373 } else {
11374 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11375 arg2 = *temp;
11376 if (SWIG_IsNewObj(res2)) delete temp;
11377 }
11378 }
11379 }
11380 if (obj2) {
11381 {
11382 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11383 if (!SWIG_IsOK(res3)) {
11384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11385 }
11386 if (!argp3) {
11387 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11388 } else {
11389 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11390 arg3 = *temp;
11391 if (SWIG_IsNewObj(res3)) delete temp;
11392 }
11393 }
11394 }
11395 if (obj3) {
11396 {
11397 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11398 if (!SWIG_IsOK(res4)) {
11399 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11400 }
11401 if (!argp4) {
11402 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11403 } else {
11404 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11405 arg4 = *temp;
11406 if (SWIG_IsNewObj(res4)) delete temp;
11407 }
11408 }
11409 }
11410 if (obj4) {
11411 {
11412 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11413 if (!SWIG_IsOK(res5)) {
11414 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11415 }
11416 if (!argp5) {
11417 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11418 } else {
11419 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11420 arg5 = *temp;
11421 if (SWIG_IsNewObj(res5)) delete temp;
11422 }
11423 }
11424 }
11425 {
11426 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 resultobj = SWIG_Py_Void();
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11437 PyObject *resultobj = 0;
11438 wxRect2D *arg1 = (wxRect2D *) 0 ;
11439 PyObject *result = 0 ;
11440 void *argp1 = 0 ;
11441 int res1 = 0 ;
11442 PyObject *swig_obj[1] ;
11443
11444 if (!args) SWIG_fail;
11445 swig_obj[0] = args;
11446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11447 if (!SWIG_IsOK(res1)) {
11448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11449 }
11450 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11451 {
11452 result = (PyObject *)wxRect2D_Get(arg1);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 resultobj = result;
11456 return resultobj;
11457 fail:
11458 return NULL;
11459 }
11460
11461
11462 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11463 PyObject *obj;
11464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11465 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11466 return SWIG_Py_Void();
11467 }
11468
11469 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11470 return SWIG_Python_InitShadowInstance(args);
11471 }
11472
11473 SWIGINTERN int DefaultPosition_set(PyObject *) {
11474 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11475 return 1;
11476 }
11477
11478
11479 SWIGINTERN PyObject *DefaultPosition_get(void) {
11480 PyObject *pyobj = 0;
11481
11482 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11483 return pyobj;
11484 }
11485
11486
11487 SWIGINTERN int DefaultSize_set(PyObject *) {
11488 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11489 return 1;
11490 }
11491
11492
11493 SWIGINTERN PyObject *DefaultSize_get(void) {
11494 PyObject *pyobj = 0;
11495
11496 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11497 return pyobj;
11498 }
11499
11500
11501 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11502 PyObject *resultobj = 0;
11503 PyObject *arg1 = (PyObject *) 0 ;
11504 wxPyInputStream *result = 0 ;
11505 PyObject * obj0 = 0 ;
11506 char * kwnames[] = {
11507 (char *) "p", NULL
11508 };
11509
11510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11511 arg1 = obj0;
11512 {
11513 PyThreadState* __tstate = wxPyBeginAllowThreads();
11514 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11526 PyObject *resultobj = 0;
11527 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11528 void *argp1 = 0 ;
11529 int res1 = 0 ;
11530 PyObject *swig_obj[1] ;
11531
11532 if (!args) SWIG_fail;
11533 swig_obj[0] = args;
11534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11537 }
11538 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 delete arg1;
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 resultobj = SWIG_Py_Void();
11547 return resultobj;
11548 fail:
11549 return NULL;
11550 }
11551
11552
11553 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11554 PyObject *resultobj = 0;
11555 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11556 void *argp1 = 0 ;
11557 int res1 = 0 ;
11558 PyObject *swig_obj[1] ;
11559
11560 if (!args) SWIG_fail;
11561 swig_obj[0] = args;
11562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11563 if (!SWIG_IsOK(res1)) {
11564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11565 }
11566 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11567 {
11568 PyThreadState* __tstate = wxPyBeginAllowThreads();
11569 (arg1)->close();
11570 wxPyEndAllowThreads(__tstate);
11571 if (PyErr_Occurred()) SWIG_fail;
11572 }
11573 resultobj = SWIG_Py_Void();
11574 return resultobj;
11575 fail:
11576 return NULL;
11577 }
11578
11579
11580 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11581 PyObject *resultobj = 0;
11582 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11583 void *argp1 = 0 ;
11584 int res1 = 0 ;
11585 PyObject *swig_obj[1] ;
11586
11587 if (!args) SWIG_fail;
11588 swig_obj[0] = args;
11589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11590 if (!SWIG_IsOK(res1)) {
11591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11592 }
11593 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 (arg1)->flush();
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 resultobj = SWIG_Py_Void();
11601 return resultobj;
11602 fail:
11603 return NULL;
11604 }
11605
11606
11607 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11608 PyObject *resultobj = 0;
11609 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11610 bool result;
11611 void *argp1 = 0 ;
11612 int res1 = 0 ;
11613 PyObject *swig_obj[1] ;
11614
11615 if (!args) SWIG_fail;
11616 swig_obj[0] = args;
11617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11618 if (!SWIG_IsOK(res1)) {
11619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11620 }
11621 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11622 {
11623 PyThreadState* __tstate = wxPyBeginAllowThreads();
11624 result = (bool)(arg1)->eof();
11625 wxPyEndAllowThreads(__tstate);
11626 if (PyErr_Occurred()) SWIG_fail;
11627 }
11628 {
11629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11630 }
11631 return resultobj;
11632 fail:
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11638 PyObject *resultobj = 0;
11639 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11640 int arg2 = (int) -1 ;
11641 PyObject *result = 0 ;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 int val2 ;
11645 int ecode2 = 0 ;
11646 PyObject * obj0 = 0 ;
11647 PyObject * obj1 = 0 ;
11648 char * kwnames[] = {
11649 (char *) "self",(char *) "size", NULL
11650 };
11651
11652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11654 if (!SWIG_IsOK(res1)) {
11655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11656 }
11657 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11658 if (obj1) {
11659 ecode2 = SWIG_AsVal_int(obj1, &val2);
11660 if (!SWIG_IsOK(ecode2)) {
11661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11662 }
11663 arg2 = static_cast< int >(val2);
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (PyObject *)(arg1)->read(arg2);
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 resultobj = result;
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj = 0;
11680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11681 int arg2 = (int) -1 ;
11682 PyObject *result = 0 ;
11683 void *argp1 = 0 ;
11684 int res1 = 0 ;
11685 int val2 ;
11686 int ecode2 = 0 ;
11687 PyObject * obj0 = 0 ;
11688 PyObject * obj1 = 0 ;
11689 char * kwnames[] = {
11690 (char *) "self",(char *) "size", NULL
11691 };
11692
11693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11695 if (!SWIG_IsOK(res1)) {
11696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11697 }
11698 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11699 if (obj1) {
11700 ecode2 = SWIG_AsVal_int(obj1, &val2);
11701 if (!SWIG_IsOK(ecode2)) {
11702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11703 }
11704 arg2 = static_cast< int >(val2);
11705 }
11706 {
11707 PyThreadState* __tstate = wxPyBeginAllowThreads();
11708 result = (PyObject *)(arg1)->readline(arg2);
11709 wxPyEndAllowThreads(__tstate);
11710 if (PyErr_Occurred()) SWIG_fail;
11711 }
11712 resultobj = result;
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj = 0;
11721 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11722 int arg2 = (int) -1 ;
11723 PyObject *result = 0 ;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 int val2 ;
11727 int ecode2 = 0 ;
11728 PyObject * obj0 = 0 ;
11729 PyObject * obj1 = 0 ;
11730 char * kwnames[] = {
11731 (char *) "self",(char *) "sizehint", NULL
11732 };
11733
11734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11736 if (!SWIG_IsOK(res1)) {
11737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11738 }
11739 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11740 if (obj1) {
11741 ecode2 = SWIG_AsVal_int(obj1, &val2);
11742 if (!SWIG_IsOK(ecode2)) {
11743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11744 }
11745 arg2 = static_cast< int >(val2);
11746 }
11747 {
11748 PyThreadState* __tstate = wxPyBeginAllowThreads();
11749 result = (PyObject *)(arg1)->readlines(arg2);
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 resultobj = result;
11754 return resultobj;
11755 fail:
11756 return NULL;
11757 }
11758
11759
11760 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11761 PyObject *resultobj = 0;
11762 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11763 int arg2 ;
11764 int arg3 = (int) 0 ;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 int val2 ;
11768 int ecode2 = 0 ;
11769 int val3 ;
11770 int ecode3 = 0 ;
11771 PyObject * obj0 = 0 ;
11772 PyObject * obj1 = 0 ;
11773 PyObject * obj2 = 0 ;
11774 char * kwnames[] = {
11775 (char *) "self",(char *) "offset",(char *) "whence", NULL
11776 };
11777
11778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11780 if (!SWIG_IsOK(res1)) {
11781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11782 }
11783 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11784 ecode2 = SWIG_AsVal_int(obj1, &val2);
11785 if (!SWIG_IsOK(ecode2)) {
11786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11787 }
11788 arg2 = static_cast< int >(val2);
11789 if (obj2) {
11790 ecode3 = SWIG_AsVal_int(obj2, &val3);
11791 if (!SWIG_IsOK(ecode3)) {
11792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11793 }
11794 arg3 = static_cast< int >(val3);
11795 }
11796 {
11797 PyThreadState* __tstate = wxPyBeginAllowThreads();
11798 (arg1)->seek(arg2,arg3);
11799 wxPyEndAllowThreads(__tstate);
11800 if (PyErr_Occurred()) SWIG_fail;
11801 }
11802 resultobj = SWIG_Py_Void();
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11810 PyObject *resultobj = 0;
11811 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11812 int result;
11813 void *argp1 = 0 ;
11814 int res1 = 0 ;
11815 PyObject *swig_obj[1] ;
11816
11817 if (!args) SWIG_fail;
11818 swig_obj[0] = args;
11819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11820 if (!SWIG_IsOK(res1)) {
11821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11822 }
11823 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 result = (int)(arg1)->tell();
11827 wxPyEndAllowThreads(__tstate);
11828 if (PyErr_Occurred()) SWIG_fail;
11829 }
11830 resultobj = SWIG_From_int(static_cast< int >(result));
11831 return resultobj;
11832 fail:
11833 return NULL;
11834 }
11835
11836
11837 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11838 PyObject *resultobj = 0;
11839 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11840 char result;
11841 void *argp1 = 0 ;
11842 int res1 = 0 ;
11843 PyObject *swig_obj[1] ;
11844
11845 if (!args) SWIG_fail;
11846 swig_obj[0] = args;
11847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11848 if (!SWIG_IsOK(res1)) {
11849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11850 }
11851 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11852 {
11853 PyThreadState* __tstate = wxPyBeginAllowThreads();
11854 result = (char)(arg1)->Peek();
11855 wxPyEndAllowThreads(__tstate);
11856 if (PyErr_Occurred()) SWIG_fail;
11857 }
11858 resultobj = SWIG_From_char(static_cast< char >(result));
11859 return resultobj;
11860 fail:
11861 return NULL;
11862 }
11863
11864
11865 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11866 PyObject *resultobj = 0;
11867 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11868 char result;
11869 void *argp1 = 0 ;
11870 int res1 = 0 ;
11871 PyObject *swig_obj[1] ;
11872
11873 if (!args) SWIG_fail;
11874 swig_obj[0] = args;
11875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11876 if (!SWIG_IsOK(res1)) {
11877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11878 }
11879 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (char)(arg1)->GetC();
11883 wxPyEndAllowThreads(__tstate);
11884 if (PyErr_Occurred()) SWIG_fail;
11885 }
11886 resultobj = SWIG_From_char(static_cast< char >(result));
11887 return resultobj;
11888 fail:
11889 return NULL;
11890 }
11891
11892
11893 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 PyObject *resultobj = 0;
11895 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11896 size_t result;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 PyObject *swig_obj[1] ;
11900
11901 if (!args) SWIG_fail;
11902 swig_obj[0] = args;
11903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11904 if (!SWIG_IsOK(res1)) {
11905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11906 }
11907 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (size_t)(arg1)->LastRead();
11911 wxPyEndAllowThreads(__tstate);
11912 if (PyErr_Occurred()) SWIG_fail;
11913 }
11914 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11915 return resultobj;
11916 fail:
11917 return NULL;
11918 }
11919
11920
11921 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11922 PyObject *resultobj = 0;
11923 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11924 bool result;
11925 void *argp1 = 0 ;
11926 int res1 = 0 ;
11927 PyObject *swig_obj[1] ;
11928
11929 if (!args) SWIG_fail;
11930 swig_obj[0] = args;
11931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11932 if (!SWIG_IsOK(res1)) {
11933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11934 }
11935 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (bool)(arg1)->CanRead();
11939 wxPyEndAllowThreads(__tstate);
11940 if (PyErr_Occurred()) SWIG_fail;
11941 }
11942 {
11943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11944 }
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11952 PyObject *resultobj = 0;
11953 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11954 bool result;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 PyObject *swig_obj[1] ;
11958
11959 if (!args) SWIG_fail;
11960 swig_obj[0] = args;
11961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11964 }
11965 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (bool)(arg1)->Eof();
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 {
11973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11974 }
11975 return resultobj;
11976 fail:
11977 return NULL;
11978 }
11979
11980
11981 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj = 0;
11983 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11984 char arg2 ;
11985 bool result;
11986 void *argp1 = 0 ;
11987 int res1 = 0 ;
11988 char val2 ;
11989 int ecode2 = 0 ;
11990 PyObject * obj0 = 0 ;
11991 PyObject * obj1 = 0 ;
11992 char * kwnames[] = {
11993 (char *) "self",(char *) "c", NULL
11994 };
11995
11996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11998 if (!SWIG_IsOK(res1)) {
11999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12000 }
12001 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12002 ecode2 = SWIG_AsVal_char(obj1, &val2);
12003 if (!SWIG_IsOK(ecode2)) {
12004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12005 }
12006 arg2 = static_cast< char >(val2);
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (bool)(arg1)->Ungetch(arg2);
12010 wxPyEndAllowThreads(__tstate);
12011 if (PyErr_Occurred()) SWIG_fail;
12012 }
12013 {
12014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12015 }
12016 return resultobj;
12017 fail:
12018 return NULL;
12019 }
12020
12021
12022 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj = 0;
12024 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12025 long arg2 ;
12026 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12027 long result;
12028 void *argp1 = 0 ;
12029 int res1 = 0 ;
12030 long val2 ;
12031 int ecode2 = 0 ;
12032 int val3 ;
12033 int ecode3 = 0 ;
12034 PyObject * obj0 = 0 ;
12035 PyObject * obj1 = 0 ;
12036 PyObject * obj2 = 0 ;
12037 char * kwnames[] = {
12038 (char *) "self",(char *) "pos",(char *) "mode", NULL
12039 };
12040
12041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12043 if (!SWIG_IsOK(res1)) {
12044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12045 }
12046 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12047 ecode2 = SWIG_AsVal_long(obj1, &val2);
12048 if (!SWIG_IsOK(ecode2)) {
12049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12050 }
12051 arg2 = static_cast< long >(val2);
12052 if (obj2) {
12053 ecode3 = SWIG_AsVal_int(obj2, &val3);
12054 if (!SWIG_IsOK(ecode3)) {
12055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12056 }
12057 arg3 = static_cast< wxSeekMode >(val3);
12058 }
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 result = (long)(arg1)->SeekI(arg2,arg3);
12062 wxPyEndAllowThreads(__tstate);
12063 if (PyErr_Occurred()) SWIG_fail;
12064 }
12065 resultobj = SWIG_From_long(static_cast< long >(result));
12066 return resultobj;
12067 fail:
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12073 PyObject *resultobj = 0;
12074 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12075 long result;
12076 void *argp1 = 0 ;
12077 int res1 = 0 ;
12078 PyObject *swig_obj[1] ;
12079
12080 if (!args) SWIG_fail;
12081 swig_obj[0] = args;
12082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12083 if (!SWIG_IsOK(res1)) {
12084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12085 }
12086 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 result = (long)(arg1)->TellI();
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_From_long(static_cast< long >(result));
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12101 PyObject *obj;
12102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12103 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12104 return SWIG_Py_Void();
12105 }
12106
12107 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12108 return SWIG_Python_InitShadowInstance(args);
12109 }
12110
12111 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12112 PyObject *resultobj = 0;
12113 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12114 PyObject *arg2 = (PyObject *) 0 ;
12115 void *argp1 = 0 ;
12116 int res1 = 0 ;
12117 PyObject * obj0 = 0 ;
12118 PyObject * obj1 = 0 ;
12119 char * kwnames[] = {
12120 (char *) "self",(char *) "obj", NULL
12121 };
12122
12123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12125 if (!SWIG_IsOK(res1)) {
12126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12127 }
12128 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12129 arg2 = obj1;
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 wxOutputStream_write(arg1,arg2);
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 resultobj = SWIG_Py_Void();
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 PyObject *resultobj = 0;
12145 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12146 size_t result;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 PyObject *swig_obj[1] ;
12150
12151 if (!args) SWIG_fail;
12152 swig_obj[0] = args;
12153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12156 }
12157 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *obj;
12173 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12174 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12175 return SWIG_Py_Void();
12176 }
12177
12178 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxInputStream *arg1 = (wxInputStream *) 0 ;
12181 wxString *arg2 = 0 ;
12182 wxString *arg3 = 0 ;
12183 wxString *arg4 = 0 ;
12184 wxDateTime arg5 ;
12185 wxFSFile *result = 0 ;
12186 wxPyInputStream *temp1 ;
12187 bool temp2 = false ;
12188 bool temp3 = false ;
12189 bool temp4 = false ;
12190 void *argp5 ;
12191 int res5 = 0 ;
12192 PyObject * obj0 = 0 ;
12193 PyObject * obj1 = 0 ;
12194 PyObject * obj2 = 0 ;
12195 PyObject * obj3 = 0 ;
12196 PyObject * obj4 = 0 ;
12197 char * kwnames[] = {
12198 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12199 };
12200
12201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12202 {
12203 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12204 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12205 } else {
12206 PyErr_Clear(); // clear the failure of the wxPyConvert above
12207 arg1 = wxPyCBInputStream_create(obj0, true);
12208 if (arg1 == NULL) {
12209 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12210 SWIG_fail;
12211 }
12212 }
12213 }
12214 {
12215 arg2 = wxString_in_helper(obj1);
12216 if (arg2 == NULL) SWIG_fail;
12217 temp2 = true;
12218 }
12219 {
12220 arg3 = wxString_in_helper(obj2);
12221 if (arg3 == NULL) SWIG_fail;
12222 temp3 = true;
12223 }
12224 {
12225 arg4 = wxString_in_helper(obj3);
12226 if (arg4 == NULL) SWIG_fail;
12227 temp4 = true;
12228 }
12229 {
12230 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12231 if (!SWIG_IsOK(res5)) {
12232 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12233 }
12234 if (!argp5) {
12235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12236 } else {
12237 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12238 arg5 = *temp;
12239 if (SWIG_IsNewObj(res5)) delete temp;
12240 }
12241 }
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12249 {
12250 if (temp2)
12251 delete arg2;
12252 }
12253 {
12254 if (temp3)
12255 delete arg3;
12256 }
12257 {
12258 if (temp4)
12259 delete arg4;
12260 }
12261 return resultobj;
12262 fail:
12263 {
12264 if (temp2)
12265 delete arg2;
12266 }
12267 {
12268 if (temp3)
12269 delete arg3;
12270 }
12271 {
12272 if (temp4)
12273 delete arg4;
12274 }
12275 return NULL;
12276 }
12277
12278
12279 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12280 PyObject *resultobj = 0;
12281 wxFSFile *arg1 = (wxFSFile *) 0 ;
12282 void *argp1 = 0 ;
12283 int res1 = 0 ;
12284 PyObject *swig_obj[1] ;
12285
12286 if (!args) SWIG_fail;
12287 swig_obj[0] = args;
12288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12289 if (!SWIG_IsOK(res1)) {
12290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12291 }
12292 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 delete arg1;
12296
12297 wxPyEndAllowThreads(__tstate);
12298 if (PyErr_Occurred()) SWIG_fail;
12299 }
12300 resultobj = SWIG_Py_Void();
12301 return resultobj;
12302 fail:
12303 return NULL;
12304 }
12305
12306
12307 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12308 PyObject *resultobj = 0;
12309 wxFSFile *arg1 = (wxFSFile *) 0 ;
12310 wxInputStream *result = 0 ;
12311 void *argp1 = 0 ;
12312 int res1 = 0 ;
12313 PyObject *swig_obj[1] ;
12314
12315 if (!args) SWIG_fail;
12316 swig_obj[0] = args;
12317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12318 if (!SWIG_IsOK(res1)) {
12319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12320 }
12321 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12322 {
12323 PyThreadState* __tstate = wxPyBeginAllowThreads();
12324 result = (wxInputStream *)(arg1)->GetStream();
12325 wxPyEndAllowThreads(__tstate);
12326 if (PyErr_Occurred()) SWIG_fail;
12327 }
12328 {
12329 wxPyInputStream * _ptr = NULL;
12330
12331 if (result) {
12332 _ptr = new wxPyInputStream(result);
12333 }
12334 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12335 }
12336 return resultobj;
12337 fail:
12338 return NULL;
12339 }
12340
12341
12342 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12343 PyObject *resultobj = 0;
12344 wxFSFile *arg1 = (wxFSFile *) 0 ;
12345 void *argp1 = 0 ;
12346 int res1 = 0 ;
12347 PyObject *swig_obj[1] ;
12348
12349 if (!args) SWIG_fail;
12350 swig_obj[0] = args;
12351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12352 if (!SWIG_IsOK(res1)) {
12353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12354 }
12355 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12356 {
12357 PyThreadState* __tstate = wxPyBeginAllowThreads();
12358 (arg1)->DetachStream();
12359 wxPyEndAllowThreads(__tstate);
12360 if (PyErr_Occurred()) SWIG_fail;
12361 }
12362 resultobj = SWIG_Py_Void();
12363 return resultobj;
12364 fail:
12365 return NULL;
12366 }
12367
12368
12369 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12370 PyObject *resultobj = 0;
12371 wxFSFile *arg1 = (wxFSFile *) 0 ;
12372 wxString *result = 0 ;
12373 void *argp1 = 0 ;
12374 int res1 = 0 ;
12375 PyObject *swig_obj[1] ;
12376
12377 if (!args) SWIG_fail;
12378 swig_obj[0] = args;
12379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12380 if (!SWIG_IsOK(res1)) {
12381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12382 }
12383 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 {
12387 wxString const &_result_ref = (arg1)->GetMimeType();
12388 result = (wxString *) &_result_ref;
12389 }
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 {
12394 #if wxUSE_UNICODE
12395 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12396 #else
12397 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12398 #endif
12399 }
12400 return resultobj;
12401 fail:
12402 return NULL;
12403 }
12404
12405
12406 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12407 PyObject *resultobj = 0;
12408 wxFSFile *arg1 = (wxFSFile *) 0 ;
12409 wxString *result = 0 ;
12410 void *argp1 = 0 ;
12411 int res1 = 0 ;
12412 PyObject *swig_obj[1] ;
12413
12414 if (!args) SWIG_fail;
12415 swig_obj[0] = args;
12416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12417 if (!SWIG_IsOK(res1)) {
12418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12419 }
12420 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 {
12424 wxString const &_result_ref = (arg1)->GetLocation();
12425 result = (wxString *) &_result_ref;
12426 }
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 {
12431 #if wxUSE_UNICODE
12432 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12433 #else
12434 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12435 #endif
12436 }
12437 return resultobj;
12438 fail:
12439 return NULL;
12440 }
12441
12442
12443 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 PyObject *resultobj = 0;
12445 wxFSFile *arg1 = (wxFSFile *) 0 ;
12446 wxString *result = 0 ;
12447 void *argp1 = 0 ;
12448 int res1 = 0 ;
12449 PyObject *swig_obj[1] ;
12450
12451 if (!args) SWIG_fail;
12452 swig_obj[0] = args;
12453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12454 if (!SWIG_IsOK(res1)) {
12455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12456 }
12457 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 {
12461 wxString const &_result_ref = (arg1)->GetAnchor();
12462 result = (wxString *) &_result_ref;
12463 }
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 {
12468 #if wxUSE_UNICODE
12469 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12470 #else
12471 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12472 #endif
12473 }
12474 return resultobj;
12475 fail:
12476 return NULL;
12477 }
12478
12479
12480 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12481 PyObject *resultobj = 0;
12482 wxFSFile *arg1 = (wxFSFile *) 0 ;
12483 wxDateTime result;
12484 void *argp1 = 0 ;
12485 int res1 = 0 ;
12486 PyObject *swig_obj[1] ;
12487
12488 if (!args) SWIG_fail;
12489 swig_obj[0] = args;
12490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12491 if (!SWIG_IsOK(res1)) {
12492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12493 }
12494 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12495 {
12496 PyThreadState* __tstate = wxPyBeginAllowThreads();
12497 result = (arg1)->GetModificationTime();
12498 wxPyEndAllowThreads(__tstate);
12499 if (PyErr_Occurred()) SWIG_fail;
12500 }
12501 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12502 return resultobj;
12503 fail:
12504 return NULL;
12505 }
12506
12507
12508 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12509 PyObject *obj;
12510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12511 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12512 return SWIG_Py_Void();
12513 }
12514
12515 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12516 return SWIG_Python_InitShadowInstance(args);
12517 }
12518
12519 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12520 PyObject *resultobj = 0;
12521 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12522 void *argp1 = 0 ;
12523 int res1 = 0 ;
12524 PyObject *swig_obj[1] ;
12525
12526 if (!args) SWIG_fail;
12527 swig_obj[0] = args;
12528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12529 if (!SWIG_IsOK(res1)) {
12530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12531 }
12532 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12533 {
12534 PyThreadState* __tstate = wxPyBeginAllowThreads();
12535 delete arg1;
12536
12537 wxPyEndAllowThreads(__tstate);
12538 if (PyErr_Occurred()) SWIG_fail;
12539 }
12540 resultobj = SWIG_Py_Void();
12541 return resultobj;
12542 fail:
12543 return NULL;
12544 }
12545
12546
12547 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12548 PyObject *obj;
12549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12550 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12551 return SWIG_Py_Void();
12552 }
12553
12554 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12555 PyObject *resultobj = 0;
12556 wxPyFileSystemHandler *result = 0 ;
12557
12558 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj = 0;
12574 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12575 PyObject *arg2 = (PyObject *) 0 ;
12576 PyObject *arg3 = (PyObject *) 0 ;
12577 void *argp1 = 0 ;
12578 int res1 = 0 ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 PyObject * obj2 = 0 ;
12582 char * kwnames[] = {
12583 (char *) "self",(char *) "self",(char *) "_class", NULL
12584 };
12585
12586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12588 if (!SWIG_IsOK(res1)) {
12589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12590 }
12591 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12592 arg2 = obj1;
12593 arg3 = obj2;
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 (arg1)->_setCallbackInfo(arg2,arg3);
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 resultobj = SWIG_Py_Void();
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12608 PyObject *resultobj = 0;
12609 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12610 wxString *arg2 = 0 ;
12611 bool result;
12612 void *argp1 = 0 ;
12613 int res1 = 0 ;
12614 bool temp2 = false ;
12615 PyObject * obj0 = 0 ;
12616 PyObject * obj1 = 0 ;
12617 char * kwnames[] = {
12618 (char *) "self",(char *) "location", NULL
12619 };
12620
12621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12623 if (!SWIG_IsOK(res1)) {
12624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12625 }
12626 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12627 {
12628 arg2 = wxString_in_helper(obj1);
12629 if (arg2 == NULL) SWIG_fail;
12630 temp2 = true;
12631 }
12632 {
12633 PyThreadState* __tstate = wxPyBeginAllowThreads();
12634 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 {
12639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12640 }
12641 {
12642 if (temp2)
12643 delete arg2;
12644 }
12645 return resultobj;
12646 fail:
12647 {
12648 if (temp2)
12649 delete arg2;
12650 }
12651 return NULL;
12652 }
12653
12654
12655 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12656 PyObject *resultobj = 0;
12657 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12658 wxFileSystem *arg2 = 0 ;
12659 wxString *arg3 = 0 ;
12660 wxFSFile *result = 0 ;
12661 void *argp1 = 0 ;
12662 int res1 = 0 ;
12663 void *argp2 = 0 ;
12664 int res2 = 0 ;
12665 bool temp3 = false ;
12666 PyObject * obj0 = 0 ;
12667 PyObject * obj1 = 0 ;
12668 PyObject * obj2 = 0 ;
12669 char * kwnames[] = {
12670 (char *) "self",(char *) "fs",(char *) "location", NULL
12671 };
12672
12673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12675 if (!SWIG_IsOK(res1)) {
12676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12677 }
12678 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12679 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12680 if (!SWIG_IsOK(res2)) {
12681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12682 }
12683 if (!argp2) {
12684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12685 }
12686 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12687 {
12688 arg3 = wxString_in_helper(obj2);
12689 if (arg3 == NULL) SWIG_fail;
12690 temp3 = true;
12691 }
12692 {
12693 PyThreadState* __tstate = wxPyBeginAllowThreads();
12694 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12695 wxPyEndAllowThreads(__tstate);
12696 if (PyErr_Occurred()) SWIG_fail;
12697 }
12698 {
12699 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12700 }
12701 {
12702 if (temp3)
12703 delete arg3;
12704 }
12705 return resultobj;
12706 fail:
12707 {
12708 if (temp3)
12709 delete arg3;
12710 }
12711 return NULL;
12712 }
12713
12714
12715 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj = 0;
12717 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12718 wxString *arg2 = 0 ;
12719 int arg3 = (int) 0 ;
12720 wxString result;
12721 void *argp1 = 0 ;
12722 int res1 = 0 ;
12723 bool temp2 = false ;
12724 int val3 ;
12725 int ecode3 = 0 ;
12726 PyObject * obj0 = 0 ;
12727 PyObject * obj1 = 0 ;
12728 PyObject * obj2 = 0 ;
12729 char * kwnames[] = {
12730 (char *) "self",(char *) "spec",(char *) "flags", NULL
12731 };
12732
12733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12735 if (!SWIG_IsOK(res1)) {
12736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12737 }
12738 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12739 {
12740 arg2 = wxString_in_helper(obj1);
12741 if (arg2 == NULL) SWIG_fail;
12742 temp2 = true;
12743 }
12744 if (obj2) {
12745 ecode3 = SWIG_AsVal_int(obj2, &val3);
12746 if (!SWIG_IsOK(ecode3)) {
12747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12748 }
12749 arg3 = static_cast< int >(val3);
12750 }
12751 {
12752 PyThreadState* __tstate = wxPyBeginAllowThreads();
12753 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12754 wxPyEndAllowThreads(__tstate);
12755 if (PyErr_Occurred()) SWIG_fail;
12756 }
12757 {
12758 #if wxUSE_UNICODE
12759 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12760 #else
12761 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12762 #endif
12763 }
12764 {
12765 if (temp2)
12766 delete arg2;
12767 }
12768 return resultobj;
12769 fail:
12770 {
12771 if (temp2)
12772 delete arg2;
12773 }
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12779 PyObject *resultobj = 0;
12780 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12781 wxString result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 PyObject *swig_obj[1] ;
12785
12786 if (!args) SWIG_fail;
12787 swig_obj[0] = args;
12788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12789 if (!SWIG_IsOK(res1)) {
12790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12791 }
12792 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12793 {
12794 PyThreadState* __tstate = wxPyBeginAllowThreads();
12795 result = (arg1)->FindNext();
12796 wxPyEndAllowThreads(__tstate);
12797 if (PyErr_Occurred()) SWIG_fail;
12798 }
12799 {
12800 #if wxUSE_UNICODE
12801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12802 #else
12803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12804 #endif
12805 }
12806 return resultobj;
12807 fail:
12808 return NULL;
12809 }
12810
12811
12812 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12813 PyObject *resultobj = 0;
12814 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12815 wxString *arg2 = 0 ;
12816 wxString result;
12817 void *argp1 = 0 ;
12818 int res1 = 0 ;
12819 bool temp2 = false ;
12820 PyObject * obj0 = 0 ;
12821 PyObject * obj1 = 0 ;
12822 char * kwnames[] = {
12823 (char *) "self",(char *) "location", NULL
12824 };
12825
12826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12830 }
12831 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12832 {
12833 arg2 = wxString_in_helper(obj1);
12834 if (arg2 == NULL) SWIG_fail;
12835 temp2 = true;
12836 }
12837 {
12838 PyThreadState* __tstate = wxPyBeginAllowThreads();
12839 result = (arg1)->GetProtocol((wxString const &)*arg2);
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 {
12844 #if wxUSE_UNICODE
12845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12846 #else
12847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12848 #endif
12849 }
12850 {
12851 if (temp2)
12852 delete arg2;
12853 }
12854 return resultobj;
12855 fail:
12856 {
12857 if (temp2)
12858 delete arg2;
12859 }
12860 return NULL;
12861 }
12862
12863
12864 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12865 PyObject *resultobj = 0;
12866 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12867 wxString *arg2 = 0 ;
12868 wxString result;
12869 void *argp1 = 0 ;
12870 int res1 = 0 ;
12871 bool temp2 = false ;
12872 PyObject * obj0 = 0 ;
12873 PyObject * obj1 = 0 ;
12874 char * kwnames[] = {
12875 (char *) "self",(char *) "location", NULL
12876 };
12877
12878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12882 }
12883 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12884 {
12885 arg2 = wxString_in_helper(obj1);
12886 if (arg2 == NULL) SWIG_fail;
12887 temp2 = true;
12888 }
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 {
12896 #if wxUSE_UNICODE
12897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12898 #else
12899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12900 #endif
12901 }
12902 {
12903 if (temp2)
12904 delete arg2;
12905 }
12906 return resultobj;
12907 fail:
12908 {
12909 if (temp2)
12910 delete arg2;
12911 }
12912 return NULL;
12913 }
12914
12915
12916 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12917 PyObject *resultobj = 0;
12918 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12919 wxString *arg2 = 0 ;
12920 wxString result;
12921 void *argp1 = 0 ;
12922 int res1 = 0 ;
12923 bool temp2 = false ;
12924 PyObject * obj0 = 0 ;
12925 PyObject * obj1 = 0 ;
12926 char * kwnames[] = {
12927 (char *) "self",(char *) "location", NULL
12928 };
12929
12930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12932 if (!SWIG_IsOK(res1)) {
12933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12934 }
12935 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12936 {
12937 arg2 = wxString_in_helper(obj1);
12938 if (arg2 == NULL) SWIG_fail;
12939 temp2 = true;
12940 }
12941 {
12942 PyThreadState* __tstate = wxPyBeginAllowThreads();
12943 result = (arg1)->GetAnchor((wxString const &)*arg2);
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 {
12948 #if wxUSE_UNICODE
12949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12950 #else
12951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12952 #endif
12953 }
12954 {
12955 if (temp2)
12956 delete arg2;
12957 }
12958 return resultobj;
12959 fail:
12960 {
12961 if (temp2)
12962 delete arg2;
12963 }
12964 return NULL;
12965 }
12966
12967
12968 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12969 PyObject *resultobj = 0;
12970 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12971 wxString *arg2 = 0 ;
12972 wxString result;
12973 void *argp1 = 0 ;
12974 int res1 = 0 ;
12975 bool temp2 = false ;
12976 PyObject * obj0 = 0 ;
12977 PyObject * obj1 = 0 ;
12978 char * kwnames[] = {
12979 (char *) "self",(char *) "location", NULL
12980 };
12981
12982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12984 if (!SWIG_IsOK(res1)) {
12985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12986 }
12987 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12988 {
12989 arg2 = wxString_in_helper(obj1);
12990 if (arg2 == NULL) SWIG_fail;
12991 temp2 = true;
12992 }
12993 {
12994 PyThreadState* __tstate = wxPyBeginAllowThreads();
12995 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12996 wxPyEndAllowThreads(__tstate);
12997 if (PyErr_Occurred()) SWIG_fail;
12998 }
12999 {
13000 #if wxUSE_UNICODE
13001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13002 #else
13003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13004 #endif
13005 }
13006 {
13007 if (temp2)
13008 delete arg2;
13009 }
13010 return resultobj;
13011 fail:
13012 {
13013 if (temp2)
13014 delete arg2;
13015 }
13016 return NULL;
13017 }
13018
13019
13020 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13021 PyObject *resultobj = 0;
13022 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13023 wxString *arg2 = 0 ;
13024 wxString result;
13025 void *argp1 = 0 ;
13026 int res1 = 0 ;
13027 bool temp2 = false ;
13028 PyObject * obj0 = 0 ;
13029 PyObject * obj1 = 0 ;
13030 char * kwnames[] = {
13031 (char *) "self",(char *) "location", NULL
13032 };
13033
13034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13036 if (!SWIG_IsOK(res1)) {
13037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13038 }
13039 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13040 {
13041 arg2 = wxString_in_helper(obj1);
13042 if (arg2 == NULL) SWIG_fail;
13043 temp2 = true;
13044 }
13045 {
13046 PyThreadState* __tstate = wxPyBeginAllowThreads();
13047 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13048 wxPyEndAllowThreads(__tstate);
13049 if (PyErr_Occurred()) SWIG_fail;
13050 }
13051 {
13052 #if wxUSE_UNICODE
13053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13054 #else
13055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13056 #endif
13057 }
13058 {
13059 if (temp2)
13060 delete arg2;
13061 }
13062 return resultobj;
13063 fail:
13064 {
13065 if (temp2)
13066 delete arg2;
13067 }
13068 return NULL;
13069 }
13070
13071
13072 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13073 PyObject *obj;
13074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13075 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13076 return SWIG_Py_Void();
13077 }
13078
13079 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13080 return SWIG_Python_InitShadowInstance(args);
13081 }
13082
13083 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *resultobj = 0;
13085 wxFileSystem *result = 0 ;
13086
13087 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (wxFileSystem *)new wxFileSystem();
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13102 PyObject *resultobj = 0;
13103 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13104 void *argp1 = 0 ;
13105 int res1 = 0 ;
13106 PyObject *swig_obj[1] ;
13107
13108 if (!args) SWIG_fail;
13109 swig_obj[0] = args;
13110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13111 if (!SWIG_IsOK(res1)) {
13112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13113 }
13114 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 delete arg1;
13118
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 resultobj = SWIG_Py_Void();
13123 return resultobj;
13124 fail:
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj = 0;
13131 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13132 wxString *arg2 = 0 ;
13133 bool arg3 = (bool) false ;
13134 void *argp1 = 0 ;
13135 int res1 = 0 ;
13136 bool temp2 = false ;
13137 bool val3 ;
13138 int ecode3 = 0 ;
13139 PyObject * obj0 = 0 ;
13140 PyObject * obj1 = 0 ;
13141 PyObject * obj2 = 0 ;
13142 char * kwnames[] = {
13143 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13144 };
13145
13146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13150 }
13151 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13152 {
13153 arg2 = wxString_in_helper(obj1);
13154 if (arg2 == NULL) SWIG_fail;
13155 temp2 = true;
13156 }
13157 if (obj2) {
13158 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13159 if (!SWIG_IsOK(ecode3)) {
13160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13161 }
13162 arg3 = static_cast< bool >(val3);
13163 }
13164 {
13165 PyThreadState* __tstate = wxPyBeginAllowThreads();
13166 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13167 wxPyEndAllowThreads(__tstate);
13168 if (PyErr_Occurred()) SWIG_fail;
13169 }
13170 resultobj = SWIG_Py_Void();
13171 {
13172 if (temp2)
13173 delete arg2;
13174 }
13175 return resultobj;
13176 fail:
13177 {
13178 if (temp2)
13179 delete arg2;
13180 }
13181 return NULL;
13182 }
13183
13184
13185 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13186 PyObject *resultobj = 0;
13187 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13188 wxString result;
13189 void *argp1 = 0 ;
13190 int res1 = 0 ;
13191 PyObject *swig_obj[1] ;
13192
13193 if (!args) SWIG_fail;
13194 swig_obj[0] = args;
13195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13198 }
13199 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 result = (arg1)->GetPath();
13203 wxPyEndAllowThreads(__tstate);
13204 if (PyErr_Occurred()) SWIG_fail;
13205 }
13206 {
13207 #if wxUSE_UNICODE
13208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13209 #else
13210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13211 #endif
13212 }
13213 return resultobj;
13214 fail:
13215 return NULL;
13216 }
13217
13218
13219 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13220 PyObject *resultobj = 0;
13221 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13222 wxString *arg2 = 0 ;
13223 wxFSFile *result = 0 ;
13224 void *argp1 = 0 ;
13225 int res1 = 0 ;
13226 bool temp2 = false ;
13227 PyObject * obj0 = 0 ;
13228 PyObject * obj1 = 0 ;
13229 char * kwnames[] = {
13230 (char *) "self",(char *) "location", NULL
13231 };
13232
13233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13235 if (!SWIG_IsOK(res1)) {
13236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13237 }
13238 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13239 {
13240 arg2 = wxString_in_helper(obj1);
13241 if (arg2 == NULL) SWIG_fail;
13242 temp2 = true;
13243 }
13244 {
13245 PyThreadState* __tstate = wxPyBeginAllowThreads();
13246 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 {
13251 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13252 }
13253 {
13254 if (temp2)
13255 delete arg2;
13256 }
13257 return resultobj;
13258 fail:
13259 {
13260 if (temp2)
13261 delete arg2;
13262 }
13263 return NULL;
13264 }
13265
13266
13267 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13268 PyObject *resultobj = 0;
13269 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13270 wxString *arg2 = 0 ;
13271 int arg3 = (int) 0 ;
13272 wxString result;
13273 void *argp1 = 0 ;
13274 int res1 = 0 ;
13275 bool temp2 = false ;
13276 int val3 ;
13277 int ecode3 = 0 ;
13278 PyObject * obj0 = 0 ;
13279 PyObject * obj1 = 0 ;
13280 PyObject * obj2 = 0 ;
13281 char * kwnames[] = {
13282 (char *) "self",(char *) "spec",(char *) "flags", NULL
13283 };
13284
13285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13287 if (!SWIG_IsOK(res1)) {
13288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13289 }
13290 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13291 {
13292 arg2 = wxString_in_helper(obj1);
13293 if (arg2 == NULL) SWIG_fail;
13294 temp2 = true;
13295 }
13296 if (obj2) {
13297 ecode3 = SWIG_AsVal_int(obj2, &val3);
13298 if (!SWIG_IsOK(ecode3)) {
13299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13300 }
13301 arg3 = static_cast< int >(val3);
13302 }
13303 {
13304 PyThreadState* __tstate = wxPyBeginAllowThreads();
13305 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13306 wxPyEndAllowThreads(__tstate);
13307 if (PyErr_Occurred()) SWIG_fail;
13308 }
13309 {
13310 #if wxUSE_UNICODE
13311 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13312 #else
13313 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13314 #endif
13315 }
13316 {
13317 if (temp2)
13318 delete arg2;
13319 }
13320 return resultobj;
13321 fail:
13322 {
13323 if (temp2)
13324 delete arg2;
13325 }
13326 return NULL;
13327 }
13328
13329
13330 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13331 PyObject *resultobj = 0;
13332 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13333 wxString result;
13334 void *argp1 = 0 ;
13335 int res1 = 0 ;
13336 PyObject *swig_obj[1] ;
13337
13338 if (!args) SWIG_fail;
13339 swig_obj[0] = args;
13340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13341 if (!SWIG_IsOK(res1)) {
13342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13343 }
13344 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13345 {
13346 PyThreadState* __tstate = wxPyBeginAllowThreads();
13347 result = (arg1)->FindNext();
13348 wxPyEndAllowThreads(__tstate);
13349 if (PyErr_Occurred()) SWIG_fail;
13350 }
13351 {
13352 #if wxUSE_UNICODE
13353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13354 #else
13355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13356 #endif
13357 }
13358 return resultobj;
13359 fail:
13360 return NULL;
13361 }
13362
13363
13364 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13365 PyObject *resultobj = 0;
13366 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13367 int res1 = 0 ;
13368 PyObject * obj0 = 0 ;
13369 char * kwnames[] = {
13370 (char *) "handler", NULL
13371 };
13372
13373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13374 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13375 if (!SWIG_IsOK(res1)) {
13376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13377 }
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 wxFileSystem::AddHandler(arg1);
13381 wxPyEndAllowThreads(__tstate);
13382 if (PyErr_Occurred()) SWIG_fail;
13383 }
13384 resultobj = SWIG_Py_Void();
13385 return resultobj;
13386 fail:
13387 return NULL;
13388 }
13389
13390
13391 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13392 PyObject *resultobj = 0;
13393 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13394 wxFileSystemHandler *result = 0 ;
13395 void *argp1 = 0 ;
13396 int res1 = 0 ;
13397 PyObject * obj0 = 0 ;
13398 char * kwnames[] = {
13399 (char *) "handler", NULL
13400 };
13401
13402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13404 if (!SWIG_IsOK(res1)) {
13405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13406 }
13407 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13411 wxPyEndAllowThreads(__tstate);
13412 if (PyErr_Occurred()) SWIG_fail;
13413 }
13414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13422 PyObject *resultobj = 0;
13423
13424 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 wxFileSystem::CleanUpHandlers();
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 resultobj = SWIG_Py_Void();
13432 return resultobj;
13433 fail:
13434 return NULL;
13435 }
13436
13437
13438 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13439 PyObject *resultobj = 0;
13440 wxString *arg1 = 0 ;
13441 wxString result;
13442 bool temp1 = false ;
13443 PyObject * obj0 = 0 ;
13444 char * kwnames[] = {
13445 (char *) "filename", NULL
13446 };
13447
13448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13449 {
13450 arg1 = wxString_in_helper(obj0);
13451 if (arg1 == NULL) SWIG_fail;
13452 temp1 = true;
13453 }
13454 {
13455 PyThreadState* __tstate = wxPyBeginAllowThreads();
13456 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13457 wxPyEndAllowThreads(__tstate);
13458 if (PyErr_Occurred()) SWIG_fail;
13459 }
13460 {
13461 #if wxUSE_UNICODE
13462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13463 #else
13464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13465 #endif
13466 }
13467 {
13468 if (temp1)
13469 delete arg1;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (temp1)
13475 delete arg1;
13476 }
13477 return NULL;
13478 }
13479
13480
13481 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13482 PyObject *resultobj = 0;
13483 wxString *arg1 = 0 ;
13484 wxString result;
13485 bool temp1 = false ;
13486 PyObject * obj0 = 0 ;
13487 char * kwnames[] = {
13488 (char *) "url", NULL
13489 };
13490
13491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13492 {
13493 arg1 = wxString_in_helper(obj0);
13494 if (arg1 == NULL) SWIG_fail;
13495 temp1 = true;
13496 }
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 {
13504 #if wxUSE_UNICODE
13505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13506 #else
13507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13508 #endif
13509 }
13510 {
13511 if (temp1)
13512 delete arg1;
13513 }
13514 return resultobj;
13515 fail:
13516 {
13517 if (temp1)
13518 delete arg1;
13519 }
13520 return NULL;
13521 }
13522
13523
13524 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13525 PyObject *obj;
13526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13527 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13528 return SWIG_Py_Void();
13529 }
13530
13531 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13532 return SWIG_Python_InitShadowInstance(args);
13533 }
13534
13535 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13536 PyObject *resultobj = 0;
13537 wxInternetFSHandler *result = 0 ;
13538
13539 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13540 {
13541 PyThreadState* __tstate = wxPyBeginAllowThreads();
13542 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13547 return resultobj;
13548 fail:
13549 return NULL;
13550 }
13551
13552
13553 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj = 0;
13555 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13556 wxString *arg2 = 0 ;
13557 bool result;
13558 void *argp1 = 0 ;
13559 int res1 = 0 ;
13560 bool temp2 = false ;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 char * kwnames[] = {
13564 (char *) "self",(char *) "location", NULL
13565 };
13566
13567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13569 if (!SWIG_IsOK(res1)) {
13570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13571 }
13572 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13573 {
13574 arg2 = wxString_in_helper(obj1);
13575 if (arg2 == NULL) SWIG_fail;
13576 temp2 = true;
13577 }
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13581 wxPyEndAllowThreads(__tstate);
13582 if (PyErr_Occurred()) SWIG_fail;
13583 }
13584 {
13585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13586 }
13587 {
13588 if (temp2)
13589 delete arg2;
13590 }
13591 return resultobj;
13592 fail:
13593 {
13594 if (temp2)
13595 delete arg2;
13596 }
13597 return NULL;
13598 }
13599
13600
13601 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj = 0;
13603 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13604 wxFileSystem *arg2 = 0 ;
13605 wxString *arg3 = 0 ;
13606 wxFSFile *result = 0 ;
13607 void *argp1 = 0 ;
13608 int res1 = 0 ;
13609 void *argp2 = 0 ;
13610 int res2 = 0 ;
13611 bool temp3 = false ;
13612 PyObject * obj0 = 0 ;
13613 PyObject * obj1 = 0 ;
13614 PyObject * obj2 = 0 ;
13615 char * kwnames[] = {
13616 (char *) "self",(char *) "fs",(char *) "location", NULL
13617 };
13618
13619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13621 if (!SWIG_IsOK(res1)) {
13622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13623 }
13624 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13625 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13626 if (!SWIG_IsOK(res2)) {
13627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13628 }
13629 if (!argp2) {
13630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13631 }
13632 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13633 {
13634 arg3 = wxString_in_helper(obj2);
13635 if (arg3 == NULL) SWIG_fail;
13636 temp3 = true;
13637 }
13638 {
13639 PyThreadState* __tstate = wxPyBeginAllowThreads();
13640 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13641 wxPyEndAllowThreads(__tstate);
13642 if (PyErr_Occurred()) SWIG_fail;
13643 }
13644 {
13645 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13646 }
13647 {
13648 if (temp3)
13649 delete arg3;
13650 }
13651 return resultobj;
13652 fail:
13653 {
13654 if (temp3)
13655 delete arg3;
13656 }
13657 return NULL;
13658 }
13659
13660
13661 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13662 PyObject *obj;
13663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13664 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13665 return SWIG_Py_Void();
13666 }
13667
13668 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13669 return SWIG_Python_InitShadowInstance(args);
13670 }
13671
13672 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13673 PyObject *resultobj = 0;
13674 wxZipFSHandler *result = 0 ;
13675
13676 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13677 {
13678 PyThreadState* __tstate = wxPyBeginAllowThreads();
13679 result = (wxZipFSHandler *)new wxZipFSHandler();
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13684 return resultobj;
13685 fail:
13686 return NULL;
13687 }
13688
13689
13690 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13691 PyObject *resultobj = 0;
13692 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13693 wxString *arg2 = 0 ;
13694 bool result;
13695 void *argp1 = 0 ;
13696 int res1 = 0 ;
13697 bool temp2 = false ;
13698 PyObject * obj0 = 0 ;
13699 PyObject * obj1 = 0 ;
13700 char * kwnames[] = {
13701 (char *) "self",(char *) "location", NULL
13702 };
13703
13704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13706 if (!SWIG_IsOK(res1)) {
13707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13708 }
13709 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13710 {
13711 arg2 = wxString_in_helper(obj1);
13712 if (arg2 == NULL) SWIG_fail;
13713 temp2 = true;
13714 }
13715 {
13716 PyThreadState* __tstate = wxPyBeginAllowThreads();
13717 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 {
13722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13723 }
13724 {
13725 if (temp2)
13726 delete arg2;
13727 }
13728 return resultobj;
13729 fail:
13730 {
13731 if (temp2)
13732 delete arg2;
13733 }
13734 return NULL;
13735 }
13736
13737
13738 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13739 PyObject *resultobj = 0;
13740 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13741 wxFileSystem *arg2 = 0 ;
13742 wxString *arg3 = 0 ;
13743 wxFSFile *result = 0 ;
13744 void *argp1 = 0 ;
13745 int res1 = 0 ;
13746 void *argp2 = 0 ;
13747 int res2 = 0 ;
13748 bool temp3 = false ;
13749 PyObject * obj0 = 0 ;
13750 PyObject * obj1 = 0 ;
13751 PyObject * obj2 = 0 ;
13752 char * kwnames[] = {
13753 (char *) "self",(char *) "fs",(char *) "location", NULL
13754 };
13755
13756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13758 if (!SWIG_IsOK(res1)) {
13759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13760 }
13761 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13763 if (!SWIG_IsOK(res2)) {
13764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13765 }
13766 if (!argp2) {
13767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13768 }
13769 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13770 {
13771 arg3 = wxString_in_helper(obj2);
13772 if (arg3 == NULL) SWIG_fail;
13773 temp3 = true;
13774 }
13775 {
13776 PyThreadState* __tstate = wxPyBeginAllowThreads();
13777 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13778 wxPyEndAllowThreads(__tstate);
13779 if (PyErr_Occurred()) SWIG_fail;
13780 }
13781 {
13782 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13783 }
13784 {
13785 if (temp3)
13786 delete arg3;
13787 }
13788 return resultobj;
13789 fail:
13790 {
13791 if (temp3)
13792 delete arg3;
13793 }
13794 return NULL;
13795 }
13796
13797
13798 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13799 PyObject *resultobj = 0;
13800 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13801 wxString *arg2 = 0 ;
13802 int arg3 = (int) 0 ;
13803 wxString result;
13804 void *argp1 = 0 ;
13805 int res1 = 0 ;
13806 bool temp2 = false ;
13807 int val3 ;
13808 int ecode3 = 0 ;
13809 PyObject * obj0 = 0 ;
13810 PyObject * obj1 = 0 ;
13811 PyObject * obj2 = 0 ;
13812 char * kwnames[] = {
13813 (char *) "self",(char *) "spec",(char *) "flags", NULL
13814 };
13815
13816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13818 if (!SWIG_IsOK(res1)) {
13819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13820 }
13821 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13822 {
13823 arg2 = wxString_in_helper(obj1);
13824 if (arg2 == NULL) SWIG_fail;
13825 temp2 = true;
13826 }
13827 if (obj2) {
13828 ecode3 = SWIG_AsVal_int(obj2, &val3);
13829 if (!SWIG_IsOK(ecode3)) {
13830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13831 }
13832 arg3 = static_cast< int >(val3);
13833 }
13834 {
13835 PyThreadState* __tstate = wxPyBeginAllowThreads();
13836 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13837 wxPyEndAllowThreads(__tstate);
13838 if (PyErr_Occurred()) SWIG_fail;
13839 }
13840 {
13841 #if wxUSE_UNICODE
13842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13843 #else
13844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13845 #endif
13846 }
13847 {
13848 if (temp2)
13849 delete arg2;
13850 }
13851 return resultobj;
13852 fail:
13853 {
13854 if (temp2)
13855 delete arg2;
13856 }
13857 return NULL;
13858 }
13859
13860
13861 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13862 PyObject *resultobj = 0;
13863 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13864 wxString result;
13865 void *argp1 = 0 ;
13866 int res1 = 0 ;
13867 PyObject *swig_obj[1] ;
13868
13869 if (!args) SWIG_fail;
13870 swig_obj[0] = args;
13871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13872 if (!SWIG_IsOK(res1)) {
13873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13874 }
13875 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 result = (arg1)->FindNext();
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 {
13883 #if wxUSE_UNICODE
13884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13885 #else
13886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13887 #endif
13888 }
13889 return resultobj;
13890 fail:
13891 return NULL;
13892 }
13893
13894
13895 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13896 PyObject *obj;
13897 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13898 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13899 return SWIG_Py_Void();
13900 }
13901
13902 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13903 return SWIG_Python_InitShadowInstance(args);
13904 }
13905
13906 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13907 PyObject *resultobj = 0;
13908 wxString *arg1 = 0 ;
13909 wxImage *arg2 = 0 ;
13910 long arg3 ;
13911 bool temp1 = false ;
13912 void *argp2 = 0 ;
13913 int res2 = 0 ;
13914 long val3 ;
13915 int ecode3 = 0 ;
13916 PyObject * obj0 = 0 ;
13917 PyObject * obj1 = 0 ;
13918 PyObject * obj2 = 0 ;
13919 char * kwnames[] = {
13920 (char *) "filename",(char *) "image",(char *) "type", NULL
13921 };
13922
13923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13924 {
13925 arg1 = wxString_in_helper(obj0);
13926 if (arg1 == NULL) SWIG_fail;
13927 temp1 = true;
13928 }
13929 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13930 if (!SWIG_IsOK(res2)) {
13931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13932 }
13933 if (!argp2) {
13934 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13935 }
13936 arg2 = reinterpret_cast< wxImage * >(argp2);
13937 ecode3 = SWIG_AsVal_long(obj2, &val3);
13938 if (!SWIG_IsOK(ecode3)) {
13939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13940 }
13941 arg3 = static_cast< long >(val3);
13942 {
13943 PyThreadState* __tstate = wxPyBeginAllowThreads();
13944 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13945 wxPyEndAllowThreads(__tstate);
13946 if (PyErr_Occurred()) SWIG_fail;
13947 }
13948 resultobj = SWIG_Py_Void();
13949 {
13950 if (temp1)
13951 delete arg1;
13952 }
13953 return resultobj;
13954 fail:
13955 {
13956 if (temp1)
13957 delete arg1;
13958 }
13959 return NULL;
13960 }
13961
13962
13963 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13964 PyObject *resultobj = 0;
13965 wxString *arg1 = 0 ;
13966 wxBitmap *arg2 = 0 ;
13967 long arg3 ;
13968 bool temp1 = false ;
13969 void *argp2 = 0 ;
13970 int res2 = 0 ;
13971 long val3 ;
13972 int ecode3 = 0 ;
13973 PyObject * obj0 = 0 ;
13974 PyObject * obj1 = 0 ;
13975 PyObject * obj2 = 0 ;
13976 char * kwnames[] = {
13977 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13978 };
13979
13980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13981 {
13982 arg1 = wxString_in_helper(obj0);
13983 if (arg1 == NULL) SWIG_fail;
13984 temp1 = true;
13985 }
13986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13987 if (!SWIG_IsOK(res2)) {
13988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13989 }
13990 if (!argp2) {
13991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13992 }
13993 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13994 ecode3 = SWIG_AsVal_long(obj2, &val3);
13995 if (!SWIG_IsOK(ecode3)) {
13996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13997 }
13998 arg3 = static_cast< long >(val3);
13999 {
14000 PyThreadState* __tstate = wxPyBeginAllowThreads();
14001 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14002 wxPyEndAllowThreads(__tstate);
14003 if (PyErr_Occurred()) SWIG_fail;
14004 }
14005 resultobj = SWIG_Py_Void();
14006 {
14007 if (temp1)
14008 delete arg1;
14009 }
14010 return resultobj;
14011 fail:
14012 {
14013 if (temp1)
14014 delete arg1;
14015 }
14016 return NULL;
14017 }
14018
14019
14020 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14021 PyObject *resultobj = 0;
14022 wxString *arg1 = 0 ;
14023 PyObject *arg2 = (PyObject *) 0 ;
14024 bool temp1 = false ;
14025 PyObject * obj0 = 0 ;
14026 PyObject * obj1 = 0 ;
14027 char * kwnames[] = {
14028 (char *) "filename",(char *) "data", NULL
14029 };
14030
14031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14032 {
14033 arg1 = wxString_in_helper(obj0);
14034 if (arg1 == NULL) SWIG_fail;
14035 temp1 = true;
14036 }
14037 arg2 = obj1;
14038 {
14039 PyThreadState* __tstate = wxPyBeginAllowThreads();
14040 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14041 wxPyEndAllowThreads(__tstate);
14042 if (PyErr_Occurred()) SWIG_fail;
14043 }
14044 resultobj = SWIG_Py_Void();
14045 {
14046 if (temp1)
14047 delete arg1;
14048 }
14049 return resultobj;
14050 fail:
14051 {
14052 if (temp1)
14053 delete arg1;
14054 }
14055 return NULL;
14056 }
14057
14058
14059 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14060 PyObject *resultobj = 0;
14061 wxMemoryFSHandler *result = 0 ;
14062
14063 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj = 0;
14079 wxString *arg1 = 0 ;
14080 bool temp1 = false ;
14081 PyObject * obj0 = 0 ;
14082 char * kwnames[] = {
14083 (char *) "filename", NULL
14084 };
14085
14086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14087 {
14088 arg1 = wxString_in_helper(obj0);
14089 if (arg1 == NULL) SWIG_fail;
14090 temp1 = true;
14091 }
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14095 wxPyEndAllowThreads(__tstate);
14096 if (PyErr_Occurred()) SWIG_fail;
14097 }
14098 resultobj = SWIG_Py_Void();
14099 {
14100 if (temp1)
14101 delete arg1;
14102 }
14103 return resultobj;
14104 fail:
14105 {
14106 if (temp1)
14107 delete arg1;
14108 }
14109 return NULL;
14110 }
14111
14112
14113 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj = 0;
14115 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14116 wxString *arg2 = 0 ;
14117 bool result;
14118 void *argp1 = 0 ;
14119 int res1 = 0 ;
14120 bool temp2 = false ;
14121 PyObject * obj0 = 0 ;
14122 PyObject * obj1 = 0 ;
14123 char * kwnames[] = {
14124 (char *) "self",(char *) "location", NULL
14125 };
14126
14127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14129 if (!SWIG_IsOK(res1)) {
14130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14131 }
14132 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14133 {
14134 arg2 = wxString_in_helper(obj1);
14135 if (arg2 == NULL) SWIG_fail;
14136 temp2 = true;
14137 }
14138 {
14139 PyThreadState* __tstate = wxPyBeginAllowThreads();
14140 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14141 wxPyEndAllowThreads(__tstate);
14142 if (PyErr_Occurred()) SWIG_fail;
14143 }
14144 {
14145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14146 }
14147 {
14148 if (temp2)
14149 delete arg2;
14150 }
14151 return resultobj;
14152 fail:
14153 {
14154 if (temp2)
14155 delete arg2;
14156 }
14157 return NULL;
14158 }
14159
14160
14161 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj = 0;
14163 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14164 wxFileSystem *arg2 = 0 ;
14165 wxString *arg3 = 0 ;
14166 wxFSFile *result = 0 ;
14167 void *argp1 = 0 ;
14168 int res1 = 0 ;
14169 void *argp2 = 0 ;
14170 int res2 = 0 ;
14171 bool temp3 = false ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 PyObject * obj2 = 0 ;
14175 char * kwnames[] = {
14176 (char *) "self",(char *) "fs",(char *) "location", NULL
14177 };
14178
14179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14181 if (!SWIG_IsOK(res1)) {
14182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14183 }
14184 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14185 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14186 if (!SWIG_IsOK(res2)) {
14187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14188 }
14189 if (!argp2) {
14190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14191 }
14192 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14193 {
14194 arg3 = wxString_in_helper(obj2);
14195 if (arg3 == NULL) SWIG_fail;
14196 temp3 = true;
14197 }
14198 {
14199 PyThreadState* __tstate = wxPyBeginAllowThreads();
14200 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14201 wxPyEndAllowThreads(__tstate);
14202 if (PyErr_Occurred()) SWIG_fail;
14203 }
14204 {
14205 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14206 }
14207 {
14208 if (temp3)
14209 delete arg3;
14210 }
14211 return resultobj;
14212 fail:
14213 {
14214 if (temp3)
14215 delete arg3;
14216 }
14217 return NULL;
14218 }
14219
14220
14221 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj = 0;
14223 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14224 wxString *arg2 = 0 ;
14225 int arg3 = (int) 0 ;
14226 wxString result;
14227 void *argp1 = 0 ;
14228 int res1 = 0 ;
14229 bool temp2 = false ;
14230 int val3 ;
14231 int ecode3 = 0 ;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 PyObject * obj2 = 0 ;
14235 char * kwnames[] = {
14236 (char *) "self",(char *) "spec",(char *) "flags", NULL
14237 };
14238
14239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14241 if (!SWIG_IsOK(res1)) {
14242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14243 }
14244 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14245 {
14246 arg2 = wxString_in_helper(obj1);
14247 if (arg2 == NULL) SWIG_fail;
14248 temp2 = true;
14249 }
14250 if (obj2) {
14251 ecode3 = SWIG_AsVal_int(obj2, &val3);
14252 if (!SWIG_IsOK(ecode3)) {
14253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14254 }
14255 arg3 = static_cast< int >(val3);
14256 }
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 #if wxUSE_UNICODE
14265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14266 #else
14267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14268 #endif
14269 }
14270 {
14271 if (temp2)
14272 delete arg2;
14273 }
14274 return resultobj;
14275 fail:
14276 {
14277 if (temp2)
14278 delete arg2;
14279 }
14280 return NULL;
14281 }
14282
14283
14284 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14285 PyObject *resultobj = 0;
14286 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14287 wxString result;
14288 void *argp1 = 0 ;
14289 int res1 = 0 ;
14290 PyObject *swig_obj[1] ;
14291
14292 if (!args) SWIG_fail;
14293 swig_obj[0] = args;
14294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14295 if (!SWIG_IsOK(res1)) {
14296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14297 }
14298 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14299 {
14300 PyThreadState* __tstate = wxPyBeginAllowThreads();
14301 result = (arg1)->FindNext();
14302 wxPyEndAllowThreads(__tstate);
14303 if (PyErr_Occurred()) SWIG_fail;
14304 }
14305 {
14306 #if wxUSE_UNICODE
14307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14308 #else
14309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14310 #endif
14311 }
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14319 PyObject *obj;
14320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14321 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14322 return SWIG_Py_Void();
14323 }
14324
14325 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14326 return SWIG_Python_InitShadowInstance(args);
14327 }
14328
14329 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14330 PyObject *resultobj = 0;
14331 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14332 wxString result;
14333 void *argp1 = 0 ;
14334 int res1 = 0 ;
14335 PyObject *swig_obj[1] ;
14336
14337 if (!args) SWIG_fail;
14338 swig_obj[0] = args;
14339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14340 if (!SWIG_IsOK(res1)) {
14341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14342 }
14343 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14344 {
14345 PyThreadState* __tstate = wxPyBeginAllowThreads();
14346 result = (arg1)->GetName();
14347 wxPyEndAllowThreads(__tstate);
14348 if (PyErr_Occurred()) SWIG_fail;
14349 }
14350 {
14351 #if wxUSE_UNICODE
14352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14353 #else
14354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14355 #endif
14356 }
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14364 PyObject *resultobj = 0;
14365 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14366 wxString result;
14367 void *argp1 = 0 ;
14368 int res1 = 0 ;
14369 PyObject *swig_obj[1] ;
14370
14371 if (!args) SWIG_fail;
14372 swig_obj[0] = args;
14373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14374 if (!SWIG_IsOK(res1)) {
14375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14376 }
14377 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (arg1)->GetExtension();
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 #if wxUSE_UNICODE
14386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14387 #else
14388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14389 #endif
14390 }
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14398 PyObject *resultobj = 0;
14399 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14400 long result;
14401 void *argp1 = 0 ;
14402 int res1 = 0 ;
14403 PyObject *swig_obj[1] ;
14404
14405 if (!args) SWIG_fail;
14406 swig_obj[0] = args;
14407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14408 if (!SWIG_IsOK(res1)) {
14409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14410 }
14411 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (long)(arg1)->GetType();
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = SWIG_From_long(static_cast< long >(result));
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14426 PyObject *resultobj = 0;
14427 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14428 wxString result;
14429 void *argp1 = 0 ;
14430 int res1 = 0 ;
14431 PyObject *swig_obj[1] ;
14432
14433 if (!args) SWIG_fail;
14434 swig_obj[0] = args;
14435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14436 if (!SWIG_IsOK(res1)) {
14437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14438 }
14439 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14440 {
14441 PyThreadState* __tstate = wxPyBeginAllowThreads();
14442 result = (arg1)->GetMimeType();
14443 wxPyEndAllowThreads(__tstate);
14444 if (PyErr_Occurred()) SWIG_fail;
14445 }
14446 {
14447 #if wxUSE_UNICODE
14448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14449 #else
14450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14451 #endif
14452 }
14453 return resultobj;
14454 fail:
14455 return NULL;
14456 }
14457
14458
14459 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14460 PyObject *resultobj = 0;
14461 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14462 wxString *arg2 = 0 ;
14463 bool result;
14464 void *argp1 = 0 ;
14465 int res1 = 0 ;
14466 bool temp2 = false ;
14467 PyObject * obj0 = 0 ;
14468 PyObject * obj1 = 0 ;
14469 char * kwnames[] = {
14470 (char *) "self",(char *) "name", NULL
14471 };
14472
14473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14475 if (!SWIG_IsOK(res1)) {
14476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14477 }
14478 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14479 {
14480 arg2 = wxString_in_helper(obj1);
14481 if (arg2 == NULL) SWIG_fail;
14482 temp2 = true;
14483 }
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14487 wxPyEndAllowThreads(__tstate);
14488 if (PyErr_Occurred()) SWIG_fail;
14489 }
14490 {
14491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14492 }
14493 {
14494 if (temp2)
14495 delete arg2;
14496 }
14497 return resultobj;
14498 fail:
14499 {
14500 if (temp2)
14501 delete arg2;
14502 }
14503 return NULL;
14504 }
14505
14506
14507 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14508 PyObject *resultobj = 0;
14509 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14510 wxInputStream *arg2 = 0 ;
14511 bool result;
14512 void *argp1 = 0 ;
14513 int res1 = 0 ;
14514 wxPyInputStream *temp2 ;
14515 bool created2 ;
14516 PyObject * obj0 = 0 ;
14517 PyObject * obj1 = 0 ;
14518 char * kwnames[] = {
14519 (char *) "self",(char *) "stream", NULL
14520 };
14521
14522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14524 if (!SWIG_IsOK(res1)) {
14525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14526 }
14527 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14528 {
14529 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14530 arg2 = temp2->m_wxis;
14531 created2 = false;
14532 } else {
14533 PyErr_Clear(); // clear the failure of the wxPyConvert above
14534 arg2 = wxPyCBInputStream_create(obj1, false);
14535 if (arg2 == NULL) {
14536 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14537 SWIG_fail;
14538 }
14539 created2 = true;
14540 }
14541 }
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 result = (bool)(arg1)->CanRead(*arg2);
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 {
14549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14550 }
14551 {
14552 if (created2) delete arg2;
14553 }
14554 return resultobj;
14555 fail:
14556 {
14557 if (created2) delete arg2;
14558 }
14559 return NULL;
14560 }
14561
14562
14563 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14564 PyObject *resultobj = 0;
14565 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14566 wxString *arg2 = 0 ;
14567 void *argp1 = 0 ;
14568 int res1 = 0 ;
14569 bool temp2 = false ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 char * kwnames[] = {
14573 (char *) "self",(char *) "name", NULL
14574 };
14575
14576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14578 if (!SWIG_IsOK(res1)) {
14579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14580 }
14581 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14582 {
14583 arg2 = wxString_in_helper(obj1);
14584 if (arg2 == NULL) SWIG_fail;
14585 temp2 = true;
14586 }
14587 {
14588 PyThreadState* __tstate = wxPyBeginAllowThreads();
14589 (arg1)->SetName((wxString const &)*arg2);
14590 wxPyEndAllowThreads(__tstate);
14591 if (PyErr_Occurred()) SWIG_fail;
14592 }
14593 resultobj = SWIG_Py_Void();
14594 {
14595 if (temp2)
14596 delete arg2;
14597 }
14598 return resultobj;
14599 fail:
14600 {
14601 if (temp2)
14602 delete arg2;
14603 }
14604 return NULL;
14605 }
14606
14607
14608 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14609 PyObject *resultobj = 0;
14610 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14611 wxString *arg2 = 0 ;
14612 void *argp1 = 0 ;
14613 int res1 = 0 ;
14614 bool temp2 = false ;
14615 PyObject * obj0 = 0 ;
14616 PyObject * obj1 = 0 ;
14617 char * kwnames[] = {
14618 (char *) "self",(char *) "extension", NULL
14619 };
14620
14621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14623 if (!SWIG_IsOK(res1)) {
14624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14625 }
14626 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14627 {
14628 arg2 = wxString_in_helper(obj1);
14629 if (arg2 == NULL) SWIG_fail;
14630 temp2 = true;
14631 }
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 (arg1)->SetExtension((wxString const &)*arg2);
14635 wxPyEndAllowThreads(__tstate);
14636 if (PyErr_Occurred()) SWIG_fail;
14637 }
14638 resultobj = SWIG_Py_Void();
14639 {
14640 if (temp2)
14641 delete arg2;
14642 }
14643 return resultobj;
14644 fail:
14645 {
14646 if (temp2)
14647 delete arg2;
14648 }
14649 return NULL;
14650 }
14651
14652
14653 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14654 PyObject *resultobj = 0;
14655 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14656 long arg2 ;
14657 void *argp1 = 0 ;
14658 int res1 = 0 ;
14659 long val2 ;
14660 int ecode2 = 0 ;
14661 PyObject * obj0 = 0 ;
14662 PyObject * obj1 = 0 ;
14663 char * kwnames[] = {
14664 (char *) "self",(char *) "type", NULL
14665 };
14666
14667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14669 if (!SWIG_IsOK(res1)) {
14670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14671 }
14672 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14673 ecode2 = SWIG_AsVal_long(obj1, &val2);
14674 if (!SWIG_IsOK(ecode2)) {
14675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14676 }
14677 arg2 = static_cast< long >(val2);
14678 {
14679 PyThreadState* __tstate = wxPyBeginAllowThreads();
14680 (arg1)->SetType(arg2);
14681 wxPyEndAllowThreads(__tstate);
14682 if (PyErr_Occurred()) SWIG_fail;
14683 }
14684 resultobj = SWIG_Py_Void();
14685 return resultobj;
14686 fail:
14687 return NULL;
14688 }
14689
14690
14691 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14692 PyObject *resultobj = 0;
14693 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14694 wxString *arg2 = 0 ;
14695 void *argp1 = 0 ;
14696 int res1 = 0 ;
14697 bool temp2 = false ;
14698 PyObject * obj0 = 0 ;
14699 PyObject * obj1 = 0 ;
14700 char * kwnames[] = {
14701 (char *) "self",(char *) "mimetype", NULL
14702 };
14703
14704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14706 if (!SWIG_IsOK(res1)) {
14707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14708 }
14709 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14710 {
14711 arg2 = wxString_in_helper(obj1);
14712 if (arg2 == NULL) SWIG_fail;
14713 temp2 = true;
14714 }
14715 {
14716 PyThreadState* __tstate = wxPyBeginAllowThreads();
14717 (arg1)->SetMimeType((wxString const &)*arg2);
14718 wxPyEndAllowThreads(__tstate);
14719 if (PyErr_Occurred()) SWIG_fail;
14720 }
14721 resultobj = SWIG_Py_Void();
14722 {
14723 if (temp2)
14724 delete arg2;
14725 }
14726 return resultobj;
14727 fail:
14728 {
14729 if (temp2)
14730 delete arg2;
14731 }
14732 return NULL;
14733 }
14734
14735
14736 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14737 PyObject *obj;
14738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14739 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14740 return SWIG_Py_Void();
14741 }
14742
14743 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14744 PyObject *resultobj = 0;
14745 wxPyImageHandler *result = 0 ;
14746
14747 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14748 {
14749 PyThreadState* __tstate = wxPyBeginAllowThreads();
14750 result = (wxPyImageHandler *)new wxPyImageHandler();
14751 wxPyEndAllowThreads(__tstate);
14752 if (PyErr_Occurred()) SWIG_fail;
14753 }
14754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14755 return resultobj;
14756 fail:
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj = 0;
14763 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14764 PyObject *arg2 = (PyObject *) 0 ;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject * obj0 = 0 ;
14768 PyObject * obj1 = 0 ;
14769 char * kwnames[] = {
14770 (char *) "self",(char *) "self", NULL
14771 };
14772
14773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14775 if (!SWIG_IsOK(res1)) {
14776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14777 }
14778 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14779 arg2 = obj1;
14780 {
14781 PyThreadState* __tstate = wxPyBeginAllowThreads();
14782 (arg1)->_SetSelf(arg2);
14783 wxPyEndAllowThreads(__tstate);
14784 if (PyErr_Occurred()) SWIG_fail;
14785 }
14786 resultobj = SWIG_Py_Void();
14787 return resultobj;
14788 fail:
14789 return NULL;
14790 }
14791
14792
14793 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14794 PyObject *obj;
14795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14796 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14797 return SWIG_Py_Void();
14798 }
14799
14800 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14801 return SWIG_Python_InitShadowInstance(args);
14802 }
14803
14804 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14805 PyObject *resultobj = 0;
14806 wxImageHistogram *result = 0 ;
14807
14808 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14809 {
14810 PyThreadState* __tstate = wxPyBeginAllowThreads();
14811 result = (wxImageHistogram *)new wxImageHistogram();
14812 wxPyEndAllowThreads(__tstate);
14813 if (PyErr_Occurred()) SWIG_fail;
14814 }
14815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14816 return resultobj;
14817 fail:
14818 return NULL;
14819 }
14820
14821
14822 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj = 0;
14824 byte arg1 ;
14825 byte arg2 ;
14826 byte arg3 ;
14827 unsigned long result;
14828 unsigned char val1 ;
14829 int ecode1 = 0 ;
14830 unsigned char val2 ;
14831 int ecode2 = 0 ;
14832 unsigned char val3 ;
14833 int ecode3 = 0 ;
14834 PyObject * obj0 = 0 ;
14835 PyObject * obj1 = 0 ;
14836 PyObject * obj2 = 0 ;
14837 char * kwnames[] = {
14838 (char *) "r",(char *) "g",(char *) "b", NULL
14839 };
14840
14841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14842 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14843 if (!SWIG_IsOK(ecode1)) {
14844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14845 }
14846 arg1 = static_cast< byte >(val1);
14847 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14848 if (!SWIG_IsOK(ecode2)) {
14849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14850 }
14851 arg2 = static_cast< byte >(val2);
14852 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14853 if (!SWIG_IsOK(ecode3)) {
14854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14855 }
14856 arg3 = static_cast< byte >(val3);
14857 {
14858 PyThreadState* __tstate = wxPyBeginAllowThreads();
14859 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14860 wxPyEndAllowThreads(__tstate);
14861 if (PyErr_Occurred()) SWIG_fail;
14862 }
14863 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14864 return resultobj;
14865 fail:
14866 return NULL;
14867 }
14868
14869
14870 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14871 PyObject *resultobj = 0;
14872 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14873 byte *arg2 = (byte *) 0 ;
14874 byte *arg3 = (byte *) 0 ;
14875 byte *arg4 = (byte *) 0 ;
14876 byte arg5 = (byte) 1 ;
14877 byte arg6 = (byte) 0 ;
14878 byte arg7 = (byte) 0 ;
14879 bool result;
14880 void *argp1 = 0 ;
14881 int res1 = 0 ;
14882 byte temp2 ;
14883 int res2 = SWIG_TMPOBJ ;
14884 byte temp3 ;
14885 int res3 = SWIG_TMPOBJ ;
14886 byte temp4 ;
14887 int res4 = SWIG_TMPOBJ ;
14888 unsigned char val5 ;
14889 int ecode5 = 0 ;
14890 unsigned char val6 ;
14891 int ecode6 = 0 ;
14892 unsigned char val7 ;
14893 int ecode7 = 0 ;
14894 PyObject * obj0 = 0 ;
14895 PyObject * obj1 = 0 ;
14896 PyObject * obj2 = 0 ;
14897 PyObject * obj3 = 0 ;
14898 char * kwnames[] = {
14899 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14900 };
14901
14902 arg2 = &temp2;
14903 arg3 = &temp3;
14904 arg4 = &temp4;
14905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14907 if (!SWIG_IsOK(res1)) {
14908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14909 }
14910 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14911 if (obj1) {
14912 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14913 if (!SWIG_IsOK(ecode5)) {
14914 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14915 }
14916 arg5 = static_cast< byte >(val5);
14917 }
14918 if (obj2) {
14919 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14920 if (!SWIG_IsOK(ecode6)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14922 }
14923 arg6 = static_cast< byte >(val6);
14924 }
14925 if (obj3) {
14926 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14927 if (!SWIG_IsOK(ecode7)) {
14928 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14929 }
14930 arg7 = static_cast< byte >(val7);
14931 }
14932 {
14933 PyThreadState* __tstate = wxPyBeginAllowThreads();
14934 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 {
14939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14940 }
14941 if (SWIG_IsTmpObj(res2)) {
14942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14943 } else {
14944 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14946 }
14947 if (SWIG_IsTmpObj(res3)) {
14948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14949 } else {
14950 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14952 }
14953 if (SWIG_IsTmpObj(res4)) {
14954 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14955 } else {
14956 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14957 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14958 }
14959 return resultobj;
14960 fail:
14961 return NULL;
14962 }
14963
14964
14965 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14966 PyObject *resultobj = 0;
14967 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14968 unsigned long arg2 ;
14969 unsigned long result;
14970 void *argp1 = 0 ;
14971 int res1 = 0 ;
14972 unsigned long val2 ;
14973 int ecode2 = 0 ;
14974 PyObject * obj0 = 0 ;
14975 PyObject * obj1 = 0 ;
14976 char * kwnames[] = {
14977 (char *) "self",(char *) "key", NULL
14978 };
14979
14980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14982 if (!SWIG_IsOK(res1)) {
14983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14984 }
14985 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14986 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14987 if (!SWIG_IsOK(ecode2)) {
14988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14989 }
14990 arg2 = static_cast< unsigned long >(val2);
14991 {
14992 PyThreadState* __tstate = wxPyBeginAllowThreads();
14993 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14994 wxPyEndAllowThreads(__tstate);
14995 if (PyErr_Occurred()) SWIG_fail;
14996 }
14997 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14998 return resultobj;
14999 fail:
15000 return NULL;
15001 }
15002
15003
15004 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15005 PyObject *resultobj = 0;
15006 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15007 byte arg2 ;
15008 byte arg3 ;
15009 byte arg4 ;
15010 unsigned long result;
15011 void *argp1 = 0 ;
15012 int res1 = 0 ;
15013 unsigned char val2 ;
15014 int ecode2 = 0 ;
15015 unsigned char val3 ;
15016 int ecode3 = 0 ;
15017 unsigned char val4 ;
15018 int ecode4 = 0 ;
15019 PyObject * obj0 = 0 ;
15020 PyObject * obj1 = 0 ;
15021 PyObject * obj2 = 0 ;
15022 PyObject * obj3 = 0 ;
15023 char * kwnames[] = {
15024 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15025 };
15026
15027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15029 if (!SWIG_IsOK(res1)) {
15030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15031 }
15032 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15033 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15034 if (!SWIG_IsOK(ecode2)) {
15035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15036 }
15037 arg2 = static_cast< byte >(val2);
15038 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15039 if (!SWIG_IsOK(ecode3)) {
15040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15041 }
15042 arg3 = static_cast< byte >(val3);
15043 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15044 if (!SWIG_IsOK(ecode4)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15046 }
15047 arg4 = static_cast< byte >(val4);
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15055 return resultobj;
15056 fail:
15057 return NULL;
15058 }
15059
15060
15061 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj = 0;
15063 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15064 wxColour *arg2 = 0 ;
15065 unsigned long result;
15066 void *argp1 = 0 ;
15067 int res1 = 0 ;
15068 wxColour temp2 ;
15069 PyObject * obj0 = 0 ;
15070 PyObject * obj1 = 0 ;
15071 char * kwnames[] = {
15072 (char *) "self",(char *) "colour", NULL
15073 };
15074
15075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15077 if (!SWIG_IsOK(res1)) {
15078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15079 }
15080 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15081 {
15082 arg2 = &temp2;
15083 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15084 }
15085 {
15086 PyThreadState* __tstate = wxPyBeginAllowThreads();
15087 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15092 return resultobj;
15093 fail:
15094 return NULL;
15095 }
15096
15097
15098 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15099 PyObject *obj;
15100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15101 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15102 return SWIG_Py_Void();
15103 }
15104
15105 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15106 return SWIG_Python_InitShadowInstance(args);
15107 }
15108
15109 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj = 0;
15111 byte arg1 = (byte) 0 ;
15112 byte arg2 = (byte) 0 ;
15113 byte arg3 = (byte) 0 ;
15114 wxImage_RGBValue *result = 0 ;
15115 unsigned char val1 ;
15116 int ecode1 = 0 ;
15117 unsigned char val2 ;
15118 int ecode2 = 0 ;
15119 unsigned char val3 ;
15120 int ecode3 = 0 ;
15121 PyObject * obj0 = 0 ;
15122 PyObject * obj1 = 0 ;
15123 PyObject * obj2 = 0 ;
15124 char * kwnames[] = {
15125 (char *) "r",(char *) "g",(char *) "b", NULL
15126 };
15127
15128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15129 if (obj0) {
15130 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15131 if (!SWIG_IsOK(ecode1)) {
15132 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15133 }
15134 arg1 = static_cast< byte >(val1);
15135 }
15136 if (obj1) {
15137 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15138 if (!SWIG_IsOK(ecode2)) {
15139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15140 }
15141 arg2 = static_cast< byte >(val2);
15142 }
15143 if (obj2) {
15144 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15145 if (!SWIG_IsOK(ecode3)) {
15146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15147 }
15148 arg3 = static_cast< byte >(val3);
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15157 return resultobj;
15158 fail:
15159 return NULL;
15160 }
15161
15162
15163 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15164 PyObject *resultobj = 0;
15165 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15166 byte arg2 ;
15167 void *argp1 = 0 ;
15168 int res1 = 0 ;
15169 unsigned char val2 ;
15170 int ecode2 = 0 ;
15171 PyObject *swig_obj[2] ;
15172
15173 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15175 if (!SWIG_IsOK(res1)) {
15176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15177 }
15178 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15179 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15180 if (!SWIG_IsOK(ecode2)) {
15181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15182 }
15183 arg2 = static_cast< byte >(val2);
15184 if (arg1) (arg1)->red = arg2;
15185
15186 resultobj = SWIG_Py_Void();
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15194 PyObject *resultobj = 0;
15195 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15196 byte result;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 PyObject *swig_obj[1] ;
15200
15201 if (!args) SWIG_fail;
15202 swig_obj[0] = args;
15203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15204 if (!SWIG_IsOK(res1)) {
15205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15206 }
15207 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15208 result = (byte) ((arg1)->red);
15209 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15210 return resultobj;
15211 fail:
15212 return NULL;
15213 }
15214
15215
15216 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15217 PyObject *resultobj = 0;
15218 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15219 byte arg2 ;
15220 void *argp1 = 0 ;
15221 int res1 = 0 ;
15222 unsigned char val2 ;
15223 int ecode2 = 0 ;
15224 PyObject *swig_obj[2] ;
15225
15226 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15228 if (!SWIG_IsOK(res1)) {
15229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15230 }
15231 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15232 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15233 if (!SWIG_IsOK(ecode2)) {
15234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15235 }
15236 arg2 = static_cast< byte >(val2);
15237 if (arg1) (arg1)->green = arg2;
15238
15239 resultobj = SWIG_Py_Void();
15240 return resultobj;
15241 fail:
15242 return NULL;
15243 }
15244
15245
15246 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15247 PyObject *resultobj = 0;
15248 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15249 byte result;
15250 void *argp1 = 0 ;
15251 int res1 = 0 ;
15252 PyObject *swig_obj[1] ;
15253
15254 if (!args) SWIG_fail;
15255 swig_obj[0] = args;
15256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15257 if (!SWIG_IsOK(res1)) {
15258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15259 }
15260 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15261 result = (byte) ((arg1)->green);
15262 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15263 return resultobj;
15264 fail:
15265 return NULL;
15266 }
15267
15268
15269 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15270 PyObject *resultobj = 0;
15271 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15272 byte arg2 ;
15273 void *argp1 = 0 ;
15274 int res1 = 0 ;
15275 unsigned char val2 ;
15276 int ecode2 = 0 ;
15277 PyObject *swig_obj[2] ;
15278
15279 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15283 }
15284 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15285 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15286 if (!SWIG_IsOK(ecode2)) {
15287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15288 }
15289 arg2 = static_cast< byte >(val2);
15290 if (arg1) (arg1)->blue = arg2;
15291
15292 resultobj = SWIG_Py_Void();
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15300 PyObject *resultobj = 0;
15301 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15302 byte result;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject *swig_obj[1] ;
15306
15307 if (!args) SWIG_fail;
15308 swig_obj[0] = args;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15312 }
15313 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15314 result = (byte) ((arg1)->blue);
15315 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15323 PyObject *obj;
15324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15325 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15326 return SWIG_Py_Void();
15327 }
15328
15329 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15330 return SWIG_Python_InitShadowInstance(args);
15331 }
15332
15333 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj = 0;
15335 double arg1 = (double) 0.0 ;
15336 double arg2 = (double) 0.0 ;
15337 double arg3 = (double) 0.0 ;
15338 wxImage_HSVValue *result = 0 ;
15339 double val1 ;
15340 int ecode1 = 0 ;
15341 double val2 ;
15342 int ecode2 = 0 ;
15343 double val3 ;
15344 int ecode3 = 0 ;
15345 PyObject * obj0 = 0 ;
15346 PyObject * obj1 = 0 ;
15347 PyObject * obj2 = 0 ;
15348 char * kwnames[] = {
15349 (char *) "h",(char *) "s",(char *) "v", NULL
15350 };
15351
15352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15353 if (obj0) {
15354 ecode1 = SWIG_AsVal_double(obj0, &val1);
15355 if (!SWIG_IsOK(ecode1)) {
15356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15357 }
15358 arg1 = static_cast< double >(val1);
15359 }
15360 if (obj1) {
15361 ecode2 = SWIG_AsVal_double(obj1, &val2);
15362 if (!SWIG_IsOK(ecode2)) {
15363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15364 }
15365 arg2 = static_cast< double >(val2);
15366 }
15367 if (obj2) {
15368 ecode3 = SWIG_AsVal_double(obj2, &val3);
15369 if (!SWIG_IsOK(ecode3)) {
15370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15371 }
15372 arg3 = static_cast< double >(val3);
15373 }
15374 {
15375 PyThreadState* __tstate = wxPyBeginAllowThreads();
15376 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15377 wxPyEndAllowThreads(__tstate);
15378 if (PyErr_Occurred()) SWIG_fail;
15379 }
15380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15381 return resultobj;
15382 fail:
15383 return NULL;
15384 }
15385
15386
15387 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15388 PyObject *resultobj = 0;
15389 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15390 double arg2 ;
15391 void *argp1 = 0 ;
15392 int res1 = 0 ;
15393 double val2 ;
15394 int ecode2 = 0 ;
15395 PyObject *swig_obj[2] ;
15396
15397 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15399 if (!SWIG_IsOK(res1)) {
15400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15401 }
15402 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15403 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15404 if (!SWIG_IsOK(ecode2)) {
15405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15406 }
15407 arg2 = static_cast< double >(val2);
15408 if (arg1) (arg1)->hue = arg2;
15409
15410 resultobj = SWIG_Py_Void();
15411 return resultobj;
15412 fail:
15413 return NULL;
15414 }
15415
15416
15417 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15418 PyObject *resultobj = 0;
15419 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15420 double result;
15421 void *argp1 = 0 ;
15422 int res1 = 0 ;
15423 PyObject *swig_obj[1] ;
15424
15425 if (!args) SWIG_fail;
15426 swig_obj[0] = args;
15427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15430 }
15431 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15432 result = (double) ((arg1)->hue);
15433 resultobj = SWIG_From_double(static_cast< double >(result));
15434 return resultobj;
15435 fail:
15436 return NULL;
15437 }
15438
15439
15440 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15441 PyObject *resultobj = 0;
15442 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15443 double arg2 ;
15444 void *argp1 = 0 ;
15445 int res1 = 0 ;
15446 double val2 ;
15447 int ecode2 = 0 ;
15448 PyObject *swig_obj[2] ;
15449
15450 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15452 if (!SWIG_IsOK(res1)) {
15453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15454 }
15455 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15456 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15457 if (!SWIG_IsOK(ecode2)) {
15458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15459 }
15460 arg2 = static_cast< double >(val2);
15461 if (arg1) (arg1)->saturation = arg2;
15462
15463 resultobj = SWIG_Py_Void();
15464 return resultobj;
15465 fail:
15466 return NULL;
15467 }
15468
15469
15470 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15471 PyObject *resultobj = 0;
15472 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15473 double result;
15474 void *argp1 = 0 ;
15475 int res1 = 0 ;
15476 PyObject *swig_obj[1] ;
15477
15478 if (!args) SWIG_fail;
15479 swig_obj[0] = args;
15480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15481 if (!SWIG_IsOK(res1)) {
15482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15483 }
15484 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15485 result = (double) ((arg1)->saturation);
15486 resultobj = SWIG_From_double(static_cast< double >(result));
15487 return resultobj;
15488 fail:
15489 return NULL;
15490 }
15491
15492
15493 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15494 PyObject *resultobj = 0;
15495 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15496 double arg2 ;
15497 void *argp1 = 0 ;
15498 int res1 = 0 ;
15499 double val2 ;
15500 int ecode2 = 0 ;
15501 PyObject *swig_obj[2] ;
15502
15503 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15505 if (!SWIG_IsOK(res1)) {
15506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15507 }
15508 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15509 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15510 if (!SWIG_IsOK(ecode2)) {
15511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15512 }
15513 arg2 = static_cast< double >(val2);
15514 if (arg1) (arg1)->value = arg2;
15515
15516 resultobj = SWIG_Py_Void();
15517 return resultobj;
15518 fail:
15519 return NULL;
15520 }
15521
15522
15523 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15524 PyObject *resultobj = 0;
15525 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15526 double result;
15527 void *argp1 = 0 ;
15528 int res1 = 0 ;
15529 PyObject *swig_obj[1] ;
15530
15531 if (!args) SWIG_fail;
15532 swig_obj[0] = args;
15533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15534 if (!SWIG_IsOK(res1)) {
15535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15536 }
15537 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15538 result = (double) ((arg1)->value);
15539 resultobj = SWIG_From_double(static_cast< double >(result));
15540 return resultobj;
15541 fail:
15542 return NULL;
15543 }
15544
15545
15546 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15547 PyObject *obj;
15548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15549 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15550 return SWIG_Py_Void();
15551 }
15552
15553 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15554 return SWIG_Python_InitShadowInstance(args);
15555 }
15556
15557 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj = 0;
15559 wxString *arg1 = 0 ;
15560 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15561 int arg3 = (int) -1 ;
15562 wxImage *result = 0 ;
15563 bool temp1 = false ;
15564 long val2 ;
15565 int ecode2 = 0 ;
15566 int val3 ;
15567 int ecode3 = 0 ;
15568 PyObject * obj0 = 0 ;
15569 PyObject * obj1 = 0 ;
15570 PyObject * obj2 = 0 ;
15571 char * kwnames[] = {
15572 (char *) "name",(char *) "type",(char *) "index", NULL
15573 };
15574
15575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15576 {
15577 arg1 = wxString_in_helper(obj0);
15578 if (arg1 == NULL) SWIG_fail;
15579 temp1 = true;
15580 }
15581 if (obj1) {
15582 ecode2 = SWIG_AsVal_long(obj1, &val2);
15583 if (!SWIG_IsOK(ecode2)) {
15584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15585 }
15586 arg2 = static_cast< long >(val2);
15587 }
15588 if (obj2) {
15589 ecode3 = SWIG_AsVal_int(obj2, &val3);
15590 if (!SWIG_IsOK(ecode3)) {
15591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15592 }
15593 arg3 = static_cast< int >(val3);
15594 }
15595 {
15596 PyThreadState* __tstate = wxPyBeginAllowThreads();
15597 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15598 wxPyEndAllowThreads(__tstate);
15599 if (PyErr_Occurred()) SWIG_fail;
15600 }
15601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15602 {
15603 if (temp1)
15604 delete arg1;
15605 }
15606 return resultobj;
15607 fail:
15608 {
15609 if (temp1)
15610 delete arg1;
15611 }
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 void *argp1 = 0 ;
15620 int res1 = 0 ;
15621 PyObject *swig_obj[1] ;
15622
15623 if (!args) SWIG_fail;
15624 swig_obj[0] = args;
15625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15626 if (!SWIG_IsOK(res1)) {
15627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15628 }
15629 arg1 = reinterpret_cast< wxImage * >(argp1);
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 delete arg1;
15633
15634 wxPyEndAllowThreads(__tstate);
15635 if (PyErr_Occurred()) SWIG_fail;
15636 }
15637 resultobj = SWIG_Py_Void();
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj = 0;
15646 wxString *arg1 = 0 ;
15647 wxString *arg2 = 0 ;
15648 int arg3 = (int) -1 ;
15649 wxImage *result = 0 ;
15650 bool temp1 = false ;
15651 bool temp2 = false ;
15652 int val3 ;
15653 int ecode3 = 0 ;
15654 PyObject * obj0 = 0 ;
15655 PyObject * obj1 = 0 ;
15656 PyObject * obj2 = 0 ;
15657 char * kwnames[] = {
15658 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15659 };
15660
15661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15662 {
15663 arg1 = wxString_in_helper(obj0);
15664 if (arg1 == NULL) SWIG_fail;
15665 temp1 = true;
15666 }
15667 {
15668 arg2 = wxString_in_helper(obj1);
15669 if (arg2 == NULL) SWIG_fail;
15670 temp2 = true;
15671 }
15672 if (obj2) {
15673 ecode3 = SWIG_AsVal_int(obj2, &val3);
15674 if (!SWIG_IsOK(ecode3)) {
15675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15676 }
15677 arg3 = static_cast< int >(val3);
15678 }
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15686 {
15687 if (temp1)
15688 delete arg1;
15689 }
15690 {
15691 if (temp2)
15692 delete arg2;
15693 }
15694 return resultobj;
15695 fail:
15696 {
15697 if (temp1)
15698 delete arg1;
15699 }
15700 {
15701 if (temp2)
15702 delete arg2;
15703 }
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15709 PyObject *resultobj = 0;
15710 wxInputStream *arg1 = 0 ;
15711 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15712 int arg3 = (int) -1 ;
15713 wxImage *result = 0 ;
15714 wxPyInputStream *temp1 ;
15715 bool created1 ;
15716 long val2 ;
15717 int ecode2 = 0 ;
15718 int val3 ;
15719 int ecode3 = 0 ;
15720 PyObject * obj0 = 0 ;
15721 PyObject * obj1 = 0 ;
15722 PyObject * obj2 = 0 ;
15723 char * kwnames[] = {
15724 (char *) "stream",(char *) "type",(char *) "index", NULL
15725 };
15726
15727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15728 {
15729 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15730 arg1 = temp1->m_wxis;
15731 created1 = false;
15732 } else {
15733 PyErr_Clear(); // clear the failure of the wxPyConvert above
15734 arg1 = wxPyCBInputStream_create(obj0, false);
15735 if (arg1 == NULL) {
15736 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15737 SWIG_fail;
15738 }
15739 created1 = true;
15740 }
15741 }
15742 if (obj1) {
15743 ecode2 = SWIG_AsVal_long(obj1, &val2);
15744 if (!SWIG_IsOK(ecode2)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15746 }
15747 arg2 = static_cast< long >(val2);
15748 }
15749 if (obj2) {
15750 ecode3 = SWIG_AsVal_int(obj2, &val3);
15751 if (!SWIG_IsOK(ecode3)) {
15752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15753 }
15754 arg3 = static_cast< int >(val3);
15755 }
15756 {
15757 PyThreadState* __tstate = wxPyBeginAllowThreads();
15758 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15763 {
15764 if (created1) delete arg1;
15765 }
15766 return resultobj;
15767 fail:
15768 {
15769 if (created1) delete arg1;
15770 }
15771 return NULL;
15772 }
15773
15774
15775 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15776 PyObject *resultobj = 0;
15777 wxInputStream *arg1 = 0 ;
15778 wxString *arg2 = 0 ;
15779 int arg3 = (int) -1 ;
15780 wxImage *result = 0 ;
15781 wxPyInputStream *temp1 ;
15782 bool created1 ;
15783 bool temp2 = false ;
15784 int val3 ;
15785 int ecode3 = 0 ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 PyObject * obj2 = 0 ;
15789 char * kwnames[] = {
15790 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15791 };
15792
15793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15794 {
15795 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15796 arg1 = temp1->m_wxis;
15797 created1 = false;
15798 } else {
15799 PyErr_Clear(); // clear the failure of the wxPyConvert above
15800 arg1 = wxPyCBInputStream_create(obj0, false);
15801 if (arg1 == NULL) {
15802 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15803 SWIG_fail;
15804 }
15805 created1 = true;
15806 }
15807 }
15808 {
15809 arg2 = wxString_in_helper(obj1);
15810 if (arg2 == NULL) SWIG_fail;
15811 temp2 = true;
15812 }
15813 if (obj2) {
15814 ecode3 = SWIG_AsVal_int(obj2, &val3);
15815 if (!SWIG_IsOK(ecode3)) {
15816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15817 }
15818 arg3 = static_cast< int >(val3);
15819 }
15820 {
15821 PyThreadState* __tstate = wxPyBeginAllowThreads();
15822 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15823 wxPyEndAllowThreads(__tstate);
15824 if (PyErr_Occurred()) SWIG_fail;
15825 }
15826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15827 {
15828 if (created1) delete arg1;
15829 }
15830 {
15831 if (temp2)
15832 delete arg2;
15833 }
15834 return resultobj;
15835 fail:
15836 {
15837 if (created1) delete arg1;
15838 }
15839 {
15840 if (temp2)
15841 delete arg2;
15842 }
15843 return NULL;
15844 }
15845
15846
15847 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15848 PyObject *resultobj = 0;
15849 int arg1 = (int) 0 ;
15850 int arg2 = (int) 0 ;
15851 bool arg3 = (bool) true ;
15852 wxImage *result = 0 ;
15853 int val1 ;
15854 int ecode1 = 0 ;
15855 int val2 ;
15856 int ecode2 = 0 ;
15857 bool val3 ;
15858 int ecode3 = 0 ;
15859 PyObject * obj0 = 0 ;
15860 PyObject * obj1 = 0 ;
15861 PyObject * obj2 = 0 ;
15862 char * kwnames[] = {
15863 (char *) "width",(char *) "height",(char *) "clear", NULL
15864 };
15865
15866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15867 if (obj0) {
15868 ecode1 = SWIG_AsVal_int(obj0, &val1);
15869 if (!SWIG_IsOK(ecode1)) {
15870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15871 }
15872 arg1 = static_cast< int >(val1);
15873 }
15874 if (obj1) {
15875 ecode2 = SWIG_AsVal_int(obj1, &val2);
15876 if (!SWIG_IsOK(ecode2)) {
15877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15878 }
15879 arg2 = static_cast< int >(val2);
15880 }
15881 if (obj2) {
15882 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15883 if (!SWIG_IsOK(ecode3)) {
15884 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15885 }
15886 arg3 = static_cast< bool >(val3);
15887 }
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15895 return resultobj;
15896 fail:
15897 return NULL;
15898 }
15899
15900
15901 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15902 PyObject *resultobj = 0;
15903 wxBitmap *arg1 = 0 ;
15904 wxImage *result = 0 ;
15905 void *argp1 = 0 ;
15906 int res1 = 0 ;
15907 PyObject * obj0 = 0 ;
15908 char * kwnames[] = {
15909 (char *) "bitmap", NULL
15910 };
15911
15912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15913 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15914 if (!SWIG_IsOK(res1)) {
15915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15916 }
15917 if (!argp1) {
15918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15919 }
15920 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15921 {
15922 if (!wxPyCheckForApp()) SWIG_fail;
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = 0;
15937 int arg1 ;
15938 int arg2 ;
15939 buffer arg3 ;
15940 int arg4 ;
15941 wxImage *result = 0 ;
15942 int val1 ;
15943 int ecode1 = 0 ;
15944 int val2 ;
15945 int ecode2 = 0 ;
15946 Py_ssize_t temp3 ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 PyObject * obj2 = 0 ;
15950 char * kwnames[] = {
15951 (char *) "width",(char *) "height",(char *) "data", NULL
15952 };
15953
15954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15955 ecode1 = SWIG_AsVal_int(obj0, &val1);
15956 if (!SWIG_IsOK(ecode1)) {
15957 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15958 }
15959 arg1 = static_cast< int >(val1);
15960 ecode2 = SWIG_AsVal_int(obj1, &val2);
15961 if (!SWIG_IsOK(ecode2)) {
15962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15963 }
15964 arg2 = static_cast< int >(val2);
15965 {
15966 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15967 arg4 = (int)temp3;
15968 }
15969 {
15970 PyThreadState* __tstate = wxPyBeginAllowThreads();
15971 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15972 wxPyEndAllowThreads(__tstate);
15973 if (PyErr_Occurred()) SWIG_fail;
15974 }
15975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15976 return resultobj;
15977 fail:
15978 return NULL;
15979 }
15980
15981
15982 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15983 PyObject *resultobj = 0;
15984 int arg1 ;
15985 int arg2 ;
15986 buffer arg3 ;
15987 int arg4 ;
15988 buffer arg5 ;
15989 int arg6 ;
15990 wxImage *result = 0 ;
15991 int val1 ;
15992 int ecode1 = 0 ;
15993 int val2 ;
15994 int ecode2 = 0 ;
15995 Py_ssize_t temp3 ;
15996 Py_ssize_t temp5 ;
15997 PyObject * obj0 = 0 ;
15998 PyObject * obj1 = 0 ;
15999 PyObject * obj2 = 0 ;
16000 PyObject * obj3 = 0 ;
16001 char * kwnames[] = {
16002 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16003 };
16004
16005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16006 ecode1 = SWIG_AsVal_int(obj0, &val1);
16007 if (!SWIG_IsOK(ecode1)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16009 }
16010 arg1 = static_cast< int >(val1);
16011 ecode2 = SWIG_AsVal_int(obj1, &val2);
16012 if (!SWIG_IsOK(ecode2)) {
16013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16014 }
16015 arg2 = static_cast< int >(val2);
16016 {
16017 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16018 arg4 = (int)temp3;
16019 }
16020 {
16021 if (obj3 != Py_None) {
16022 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16023 arg6 = (int)temp5;
16024 }
16025 }
16026 {
16027 PyThreadState* __tstate = wxPyBeginAllowThreads();
16028 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16029 wxPyEndAllowThreads(__tstate);
16030 if (PyErr_Occurred()) SWIG_fail;
16031 }
16032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj = 0;
16041 wxImage *arg1 = (wxImage *) 0 ;
16042 int arg2 ;
16043 int arg3 ;
16044 bool arg4 = (bool) true ;
16045 void *argp1 = 0 ;
16046 int res1 = 0 ;
16047 int val2 ;
16048 int ecode2 = 0 ;
16049 int val3 ;
16050 int ecode3 = 0 ;
16051 bool val4 ;
16052 int ecode4 = 0 ;
16053 PyObject * obj0 = 0 ;
16054 PyObject * obj1 = 0 ;
16055 PyObject * obj2 = 0 ;
16056 PyObject * obj3 = 0 ;
16057 char * kwnames[] = {
16058 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16059 };
16060
16061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16063 if (!SWIG_IsOK(res1)) {
16064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16065 }
16066 arg1 = reinterpret_cast< wxImage * >(argp1);
16067 ecode2 = SWIG_AsVal_int(obj1, &val2);
16068 if (!SWIG_IsOK(ecode2)) {
16069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16070 }
16071 arg2 = static_cast< int >(val2);
16072 ecode3 = SWIG_AsVal_int(obj2, &val3);
16073 if (!SWIG_IsOK(ecode3)) {
16074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16075 }
16076 arg3 = static_cast< int >(val3);
16077 if (obj3) {
16078 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16079 if (!SWIG_IsOK(ecode4)) {
16080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16081 }
16082 arg4 = static_cast< bool >(val4);
16083 }
16084 {
16085 PyThreadState* __tstate = wxPyBeginAllowThreads();
16086 (arg1)->Create(arg2,arg3,arg4);
16087 wxPyEndAllowThreads(__tstate);
16088 if (PyErr_Occurred()) SWIG_fail;
16089 }
16090 resultobj = SWIG_Py_Void();
16091 return resultobj;
16092 fail:
16093 return NULL;
16094 }
16095
16096
16097 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16098 PyObject *resultobj = 0;
16099 wxImage *arg1 = (wxImage *) 0 ;
16100 void *argp1 = 0 ;
16101 int res1 = 0 ;
16102 PyObject *swig_obj[1] ;
16103
16104 if (!args) SWIG_fail;
16105 swig_obj[0] = args;
16106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16107 if (!SWIG_IsOK(res1)) {
16108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16109 }
16110 arg1 = reinterpret_cast< wxImage * >(argp1);
16111 {
16112 PyThreadState* __tstate = wxPyBeginAllowThreads();
16113 (arg1)->Destroy();
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 resultobj = SWIG_Py_Void();
16118 return resultobj;
16119 fail:
16120 return NULL;
16121 }
16122
16123
16124 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16125 PyObject *resultobj = 0;
16126 wxImage *arg1 = (wxImage *) 0 ;
16127 int arg2 ;
16128 int arg3 ;
16129 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16130 SwigValueWrapper<wxImage > result;
16131 void *argp1 = 0 ;
16132 int res1 = 0 ;
16133 int val2 ;
16134 int ecode2 = 0 ;
16135 int val3 ;
16136 int ecode3 = 0 ;
16137 int val4 ;
16138 int ecode4 = 0 ;
16139 PyObject * obj0 = 0 ;
16140 PyObject * obj1 = 0 ;
16141 PyObject * obj2 = 0 ;
16142 PyObject * obj3 = 0 ;
16143 char * kwnames[] = {
16144 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16145 };
16146
16147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16149 if (!SWIG_IsOK(res1)) {
16150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16151 }
16152 arg1 = reinterpret_cast< wxImage * >(argp1);
16153 ecode2 = SWIG_AsVal_int(obj1, &val2);
16154 if (!SWIG_IsOK(ecode2)) {
16155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16156 }
16157 arg2 = static_cast< int >(val2);
16158 ecode3 = SWIG_AsVal_int(obj2, &val3);
16159 if (!SWIG_IsOK(ecode3)) {
16160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16161 }
16162 arg3 = static_cast< int >(val3);
16163 if (obj3) {
16164 ecode4 = SWIG_AsVal_int(obj3, &val4);
16165 if (!SWIG_IsOK(ecode4)) {
16166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16167 }
16168 arg4 = static_cast< int >(val4);
16169 }
16170 {
16171 PyThreadState* __tstate = wxPyBeginAllowThreads();
16172 result = (arg1)->Scale(arg2,arg3,arg4);
16173 wxPyEndAllowThreads(__tstate);
16174 if (PyErr_Occurred()) SWIG_fail;
16175 }
16176 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16177 return resultobj;
16178 fail:
16179 return NULL;
16180 }
16181
16182
16183 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16184 PyObject *resultobj = 0;
16185 wxImage *arg1 = (wxImage *) 0 ;
16186 int arg2 ;
16187 int arg3 ;
16188 SwigValueWrapper<wxImage > result;
16189 void *argp1 = 0 ;
16190 int res1 = 0 ;
16191 int val2 ;
16192 int ecode2 = 0 ;
16193 int val3 ;
16194 int ecode3 = 0 ;
16195 PyObject * obj0 = 0 ;
16196 PyObject * obj1 = 0 ;
16197 PyObject * obj2 = 0 ;
16198 char * kwnames[] = {
16199 (char *) "self",(char *) "width",(char *) "height", NULL
16200 };
16201
16202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16204 if (!SWIG_IsOK(res1)) {
16205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16206 }
16207 arg1 = reinterpret_cast< wxImage * >(argp1);
16208 ecode2 = SWIG_AsVal_int(obj1, &val2);
16209 if (!SWIG_IsOK(ecode2)) {
16210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16211 }
16212 arg2 = static_cast< int >(val2);
16213 ecode3 = SWIG_AsVal_int(obj2, &val3);
16214 if (!SWIG_IsOK(ecode3)) {
16215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16216 }
16217 arg3 = static_cast< int >(val3);
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = 0;
16233 wxImage *arg1 = (wxImage *) 0 ;
16234 int arg2 ;
16235 int arg3 ;
16236 SwigValueWrapper<wxImage > result;
16237 void *argp1 = 0 ;
16238 int res1 = 0 ;
16239 int val2 ;
16240 int ecode2 = 0 ;
16241 int val3 ;
16242 int ecode3 = 0 ;
16243 PyObject * obj0 = 0 ;
16244 PyObject * obj1 = 0 ;
16245 PyObject * obj2 = 0 ;
16246 char * kwnames[] = {
16247 (char *) "self",(char *) "width",(char *) "height", NULL
16248 };
16249
16250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16252 if (!SWIG_IsOK(res1)) {
16253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16254 }
16255 arg1 = reinterpret_cast< wxImage * >(argp1);
16256 ecode2 = SWIG_AsVal_int(obj1, &val2);
16257 if (!SWIG_IsOK(ecode2)) {
16258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16259 }
16260 arg2 = static_cast< int >(val2);
16261 ecode3 = SWIG_AsVal_int(obj2, &val3);
16262 if (!SWIG_IsOK(ecode3)) {
16263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16264 }
16265 arg3 = static_cast< int >(val3);
16266 {
16267 PyThreadState* __tstate = wxPyBeginAllowThreads();
16268 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16269 wxPyEndAllowThreads(__tstate);
16270 if (PyErr_Occurred()) SWIG_fail;
16271 }
16272 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16273 return resultobj;
16274 fail:
16275 return NULL;
16276 }
16277
16278
16279 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16280 PyObject *resultobj = 0;
16281 wxImage *arg1 = (wxImage *) 0 ;
16282 int arg2 ;
16283 SwigValueWrapper<wxImage > result;
16284 void *argp1 = 0 ;
16285 int res1 = 0 ;
16286 int val2 ;
16287 int ecode2 = 0 ;
16288 PyObject * obj0 = 0 ;
16289 PyObject * obj1 = 0 ;
16290 char * kwnames[] = {
16291 (char *) "self",(char *) "radius", NULL
16292 };
16293
16294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16296 if (!SWIG_IsOK(res1)) {
16297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16298 }
16299 arg1 = reinterpret_cast< wxImage * >(argp1);
16300 ecode2 = SWIG_AsVal_int(obj1, &val2);
16301 if (!SWIG_IsOK(ecode2)) {
16302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16303 }
16304 arg2 = static_cast< int >(val2);
16305 {
16306 PyThreadState* __tstate = wxPyBeginAllowThreads();
16307 result = (arg1)->Blur(arg2);
16308 wxPyEndAllowThreads(__tstate);
16309 if (PyErr_Occurred()) SWIG_fail;
16310 }
16311 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16312 return resultobj;
16313 fail:
16314 return NULL;
16315 }
16316
16317
16318 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16319 PyObject *resultobj = 0;
16320 wxImage *arg1 = (wxImage *) 0 ;
16321 int arg2 ;
16322 SwigValueWrapper<wxImage > result;
16323 void *argp1 = 0 ;
16324 int res1 = 0 ;
16325 int val2 ;
16326 int ecode2 = 0 ;
16327 PyObject * obj0 = 0 ;
16328 PyObject * obj1 = 0 ;
16329 char * kwnames[] = {
16330 (char *) "self",(char *) "radius", NULL
16331 };
16332
16333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16335 if (!SWIG_IsOK(res1)) {
16336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16337 }
16338 arg1 = reinterpret_cast< wxImage * >(argp1);
16339 ecode2 = SWIG_AsVal_int(obj1, &val2);
16340 if (!SWIG_IsOK(ecode2)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16342 }
16343 arg2 = static_cast< int >(val2);
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = (arg1)->BlurHorizontal(arg2);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = 0;
16359 wxImage *arg1 = (wxImage *) 0 ;
16360 int arg2 ;
16361 SwigValueWrapper<wxImage > result;
16362 void *argp1 = 0 ;
16363 int res1 = 0 ;
16364 int val2 ;
16365 int ecode2 = 0 ;
16366 PyObject * obj0 = 0 ;
16367 PyObject * obj1 = 0 ;
16368 char * kwnames[] = {
16369 (char *) "self",(char *) "radius", NULL
16370 };
16371
16372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16374 if (!SWIG_IsOK(res1)) {
16375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16376 }
16377 arg1 = reinterpret_cast< wxImage * >(argp1);
16378 ecode2 = SWIG_AsVal_int(obj1, &val2);
16379 if (!SWIG_IsOK(ecode2)) {
16380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16381 }
16382 arg2 = static_cast< int >(val2);
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 result = (arg1)->BlurVertical(arg2);
16386 wxPyEndAllowThreads(__tstate);
16387 if (PyErr_Occurred()) SWIG_fail;
16388 }
16389 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16390 return resultobj;
16391 fail:
16392 return NULL;
16393 }
16394
16395
16396 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16397 PyObject *resultobj = 0;
16398 wxImage *arg1 = (wxImage *) 0 ;
16399 int arg2 ;
16400 int arg3 ;
16401 SwigValueWrapper<wxImage > result;
16402 void *argp1 = 0 ;
16403 int res1 = 0 ;
16404 int val2 ;
16405 int ecode2 = 0 ;
16406 int val3 ;
16407 int ecode3 = 0 ;
16408 PyObject * obj0 = 0 ;
16409 PyObject * obj1 = 0 ;
16410 PyObject * obj2 = 0 ;
16411 char * kwnames[] = {
16412 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16413 };
16414
16415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16417 if (!SWIG_IsOK(res1)) {
16418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16419 }
16420 arg1 = reinterpret_cast< wxImage * >(argp1);
16421 ecode2 = SWIG_AsVal_int(obj1, &val2);
16422 if (!SWIG_IsOK(ecode2)) {
16423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16424 }
16425 arg2 = static_cast< int >(val2);
16426 ecode3 = SWIG_AsVal_int(obj2, &val3);
16427 if (!SWIG_IsOK(ecode3)) {
16428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16429 }
16430 arg3 = static_cast< int >(val3);
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj = 0;
16446 wxImage *arg1 = (wxImage *) 0 ;
16447 int arg2 ;
16448 int arg3 ;
16449 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16450 wxImage *result = 0 ;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 int val2 ;
16454 int ecode2 = 0 ;
16455 int val3 ;
16456 int ecode3 = 0 ;
16457 int val4 ;
16458 int ecode4 = 0 ;
16459 PyObject * obj0 = 0 ;
16460 PyObject * obj1 = 0 ;
16461 PyObject * obj2 = 0 ;
16462 PyObject * obj3 = 0 ;
16463 char * kwnames[] = {
16464 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16465 };
16466
16467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16469 if (!SWIG_IsOK(res1)) {
16470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16471 }
16472 arg1 = reinterpret_cast< wxImage * >(argp1);
16473 ecode2 = SWIG_AsVal_int(obj1, &val2);
16474 if (!SWIG_IsOK(ecode2)) {
16475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16476 }
16477 arg2 = static_cast< int >(val2);
16478 ecode3 = SWIG_AsVal_int(obj2, &val3);
16479 if (!SWIG_IsOK(ecode3)) {
16480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16481 }
16482 arg3 = static_cast< int >(val3);
16483 if (obj3) {
16484 ecode4 = SWIG_AsVal_int(obj3, &val4);
16485 if (!SWIG_IsOK(ecode4)) {
16486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16487 }
16488 arg4 = static_cast< int >(val4);
16489 }
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 {
16493 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16494 result = (wxImage *) &_result_ref;
16495 }
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16500 return resultobj;
16501 fail:
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16507 PyObject *resultobj = 0;
16508 wxImage *arg1 = (wxImage *) 0 ;
16509 wxSize *arg2 = 0 ;
16510 wxPoint *arg3 = 0 ;
16511 int arg4 = (int) -1 ;
16512 int arg5 = (int) -1 ;
16513 int arg6 = (int) -1 ;
16514 wxImage *result = 0 ;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 wxSize temp2 ;
16518 wxPoint temp3 ;
16519 int val4 ;
16520 int ecode4 = 0 ;
16521 int val5 ;
16522 int ecode5 = 0 ;
16523 int val6 ;
16524 int ecode6 = 0 ;
16525 PyObject * obj0 = 0 ;
16526 PyObject * obj1 = 0 ;
16527 PyObject * obj2 = 0 ;
16528 PyObject * obj3 = 0 ;
16529 PyObject * obj4 = 0 ;
16530 PyObject * obj5 = 0 ;
16531 char * kwnames[] = {
16532 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16533 };
16534
16535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16537 if (!SWIG_IsOK(res1)) {
16538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16539 }
16540 arg1 = reinterpret_cast< wxImage * >(argp1);
16541 {
16542 arg2 = &temp2;
16543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16544 }
16545 {
16546 arg3 = &temp3;
16547 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16548 }
16549 if (obj3) {
16550 ecode4 = SWIG_AsVal_int(obj3, &val4);
16551 if (!SWIG_IsOK(ecode4)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16553 }
16554 arg4 = static_cast< int >(val4);
16555 }
16556 if (obj4) {
16557 ecode5 = SWIG_AsVal_int(obj4, &val5);
16558 if (!SWIG_IsOK(ecode5)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16560 }
16561 arg5 = static_cast< int >(val5);
16562 }
16563 if (obj5) {
16564 ecode6 = SWIG_AsVal_int(obj5, &val6);
16565 if (!SWIG_IsOK(ecode6)) {
16566 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16567 }
16568 arg6 = static_cast< int >(val6);
16569 }
16570 {
16571 PyThreadState* __tstate = wxPyBeginAllowThreads();
16572 {
16573 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16574 result = (wxImage *) &_result_ref;
16575 }
16576 wxPyEndAllowThreads(__tstate);
16577 if (PyErr_Occurred()) SWIG_fail;
16578 }
16579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16580 return resultobj;
16581 fail:
16582 return NULL;
16583 }
16584
16585
16586 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16587 PyObject *resultobj = 0;
16588 wxImage *arg1 = (wxImage *) 0 ;
16589 int arg2 ;
16590 int arg3 ;
16591 byte arg4 ;
16592 byte arg5 ;
16593 byte arg6 ;
16594 void *argp1 = 0 ;
16595 int res1 = 0 ;
16596 int val2 ;
16597 int ecode2 = 0 ;
16598 int val3 ;
16599 int ecode3 = 0 ;
16600 unsigned char val4 ;
16601 int ecode4 = 0 ;
16602 unsigned char val5 ;
16603 int ecode5 = 0 ;
16604 unsigned char val6 ;
16605 int ecode6 = 0 ;
16606 PyObject * obj0 = 0 ;
16607 PyObject * obj1 = 0 ;
16608 PyObject * obj2 = 0 ;
16609 PyObject * obj3 = 0 ;
16610 PyObject * obj4 = 0 ;
16611 PyObject * obj5 = 0 ;
16612 char * kwnames[] = {
16613 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16614 };
16615
16616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16618 if (!SWIG_IsOK(res1)) {
16619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16620 }
16621 arg1 = reinterpret_cast< wxImage * >(argp1);
16622 ecode2 = SWIG_AsVal_int(obj1, &val2);
16623 if (!SWIG_IsOK(ecode2)) {
16624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16625 }
16626 arg2 = static_cast< int >(val2);
16627 ecode3 = SWIG_AsVal_int(obj2, &val3);
16628 if (!SWIG_IsOK(ecode3)) {
16629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16630 }
16631 arg3 = static_cast< int >(val3);
16632 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16633 if (!SWIG_IsOK(ecode4)) {
16634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16635 }
16636 arg4 = static_cast< byte >(val4);
16637 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16638 if (!SWIG_IsOK(ecode5)) {
16639 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16640 }
16641 arg5 = static_cast< byte >(val5);
16642 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16643 if (!SWIG_IsOK(ecode6)) {
16644 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16645 }
16646 arg6 = static_cast< byte >(val6);
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16650 wxPyEndAllowThreads(__tstate);
16651 if (PyErr_Occurred()) SWIG_fail;
16652 }
16653 resultobj = SWIG_Py_Void();
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj = 0;
16662 wxImage *arg1 = (wxImage *) 0 ;
16663 wxRect *arg2 = 0 ;
16664 byte arg3 ;
16665 byte arg4 ;
16666 byte arg5 ;
16667 void *argp1 = 0 ;
16668 int res1 = 0 ;
16669 wxRect temp2 ;
16670 unsigned char val3 ;
16671 int ecode3 = 0 ;
16672 unsigned char val4 ;
16673 int ecode4 = 0 ;
16674 unsigned char val5 ;
16675 int ecode5 = 0 ;
16676 PyObject * obj0 = 0 ;
16677 PyObject * obj1 = 0 ;
16678 PyObject * obj2 = 0 ;
16679 PyObject * obj3 = 0 ;
16680 PyObject * obj4 = 0 ;
16681 char * kwnames[] = {
16682 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16683 };
16684
16685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16687 if (!SWIG_IsOK(res1)) {
16688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16689 }
16690 arg1 = reinterpret_cast< wxImage * >(argp1);
16691 {
16692 arg2 = &temp2;
16693 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16694 }
16695 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16696 if (!SWIG_IsOK(ecode3)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16698 }
16699 arg3 = static_cast< byte >(val3);
16700 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16701 if (!SWIG_IsOK(ecode4)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16703 }
16704 arg4 = static_cast< byte >(val4);
16705 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16706 if (!SWIG_IsOK(ecode5)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16708 }
16709 arg5 = static_cast< byte >(val5);
16710 {
16711 PyThreadState* __tstate = wxPyBeginAllowThreads();
16712 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16713 wxPyEndAllowThreads(__tstate);
16714 if (PyErr_Occurred()) SWIG_fail;
16715 }
16716 resultobj = SWIG_Py_Void();
16717 return resultobj;
16718 fail:
16719 return NULL;
16720 }
16721
16722
16723 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16724 PyObject *resultobj = 0;
16725 wxImage *arg1 = (wxImage *) 0 ;
16726 int arg2 ;
16727 int arg3 ;
16728 byte result;
16729 void *argp1 = 0 ;
16730 int res1 = 0 ;
16731 int val2 ;
16732 int ecode2 = 0 ;
16733 int val3 ;
16734 int ecode3 = 0 ;
16735 PyObject * obj0 = 0 ;
16736 PyObject * obj1 = 0 ;
16737 PyObject * obj2 = 0 ;
16738 char * kwnames[] = {
16739 (char *) "self",(char *) "x",(char *) "y", NULL
16740 };
16741
16742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16744 if (!SWIG_IsOK(res1)) {
16745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16746 }
16747 arg1 = reinterpret_cast< wxImage * >(argp1);
16748 ecode2 = SWIG_AsVal_int(obj1, &val2);
16749 if (!SWIG_IsOK(ecode2)) {
16750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16751 }
16752 arg2 = static_cast< int >(val2);
16753 ecode3 = SWIG_AsVal_int(obj2, &val3);
16754 if (!SWIG_IsOK(ecode3)) {
16755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16756 }
16757 arg3 = static_cast< int >(val3);
16758 {
16759 PyThreadState* __tstate = wxPyBeginAllowThreads();
16760 result = (byte)(arg1)->GetRed(arg2,arg3);
16761 wxPyEndAllowThreads(__tstate);
16762 if (PyErr_Occurred()) SWIG_fail;
16763 }
16764 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16765 return resultobj;
16766 fail:
16767 return NULL;
16768 }
16769
16770
16771 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16772 PyObject *resultobj = 0;
16773 wxImage *arg1 = (wxImage *) 0 ;
16774 int arg2 ;
16775 int arg3 ;
16776 byte result;
16777 void *argp1 = 0 ;
16778 int res1 = 0 ;
16779 int val2 ;
16780 int ecode2 = 0 ;
16781 int val3 ;
16782 int ecode3 = 0 ;
16783 PyObject * obj0 = 0 ;
16784 PyObject * obj1 = 0 ;
16785 PyObject * obj2 = 0 ;
16786 char * kwnames[] = {
16787 (char *) "self",(char *) "x",(char *) "y", NULL
16788 };
16789
16790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16792 if (!SWIG_IsOK(res1)) {
16793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16794 }
16795 arg1 = reinterpret_cast< wxImage * >(argp1);
16796 ecode2 = SWIG_AsVal_int(obj1, &val2);
16797 if (!SWIG_IsOK(ecode2)) {
16798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16799 }
16800 arg2 = static_cast< int >(val2);
16801 ecode3 = SWIG_AsVal_int(obj2, &val3);
16802 if (!SWIG_IsOK(ecode3)) {
16803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16804 }
16805 arg3 = static_cast< int >(val3);
16806 {
16807 PyThreadState* __tstate = wxPyBeginAllowThreads();
16808 result = (byte)(arg1)->GetGreen(arg2,arg3);
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16820 PyObject *resultobj = 0;
16821 wxImage *arg1 = (wxImage *) 0 ;
16822 int arg2 ;
16823 int arg3 ;
16824 byte result;
16825 void *argp1 = 0 ;
16826 int res1 = 0 ;
16827 int val2 ;
16828 int ecode2 = 0 ;
16829 int val3 ;
16830 int ecode3 = 0 ;
16831 PyObject * obj0 = 0 ;
16832 PyObject * obj1 = 0 ;
16833 PyObject * obj2 = 0 ;
16834 char * kwnames[] = {
16835 (char *) "self",(char *) "x",(char *) "y", NULL
16836 };
16837
16838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16840 if (!SWIG_IsOK(res1)) {
16841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16842 }
16843 arg1 = reinterpret_cast< wxImage * >(argp1);
16844 ecode2 = SWIG_AsVal_int(obj1, &val2);
16845 if (!SWIG_IsOK(ecode2)) {
16846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16847 }
16848 arg2 = static_cast< int >(val2);
16849 ecode3 = SWIG_AsVal_int(obj2, &val3);
16850 if (!SWIG_IsOK(ecode3)) {
16851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16852 }
16853 arg3 = static_cast< int >(val3);
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (byte)(arg1)->GetBlue(arg2,arg3);
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16868 PyObject *resultobj = 0;
16869 wxImage *arg1 = (wxImage *) 0 ;
16870 int arg2 ;
16871 int arg3 ;
16872 byte arg4 ;
16873 void *argp1 = 0 ;
16874 int res1 = 0 ;
16875 int val2 ;
16876 int ecode2 = 0 ;
16877 int val3 ;
16878 int ecode3 = 0 ;
16879 unsigned char val4 ;
16880 int ecode4 = 0 ;
16881 PyObject * obj0 = 0 ;
16882 PyObject * obj1 = 0 ;
16883 PyObject * obj2 = 0 ;
16884 PyObject * obj3 = 0 ;
16885 char * kwnames[] = {
16886 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16887 };
16888
16889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16893 }
16894 arg1 = reinterpret_cast< wxImage * >(argp1);
16895 ecode2 = SWIG_AsVal_int(obj1, &val2);
16896 if (!SWIG_IsOK(ecode2)) {
16897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16898 }
16899 arg2 = static_cast< int >(val2);
16900 ecode3 = SWIG_AsVal_int(obj2, &val3);
16901 if (!SWIG_IsOK(ecode3)) {
16902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16903 }
16904 arg3 = static_cast< int >(val3);
16905 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16906 if (!SWIG_IsOK(ecode4)) {
16907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16908 }
16909 arg4 = static_cast< byte >(val4);
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 (arg1)->SetAlpha(arg2,arg3,arg4);
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 resultobj = SWIG_Py_Void();
16917 return resultobj;
16918 fail:
16919 return NULL;
16920 }
16921
16922
16923 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16924 PyObject *resultobj = 0;
16925 wxImage *arg1 = (wxImage *) 0 ;
16926 int arg2 ;
16927 int arg3 ;
16928 byte result;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 int val2 ;
16932 int ecode2 = 0 ;
16933 int val3 ;
16934 int ecode3 = 0 ;
16935 PyObject * obj0 = 0 ;
16936 PyObject * obj1 = 0 ;
16937 PyObject * obj2 = 0 ;
16938 char * kwnames[] = {
16939 (char *) "self",(char *) "x",(char *) "y", NULL
16940 };
16941
16942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16946 }
16947 arg1 = reinterpret_cast< wxImage * >(argp1);
16948 ecode2 = SWIG_AsVal_int(obj1, &val2);
16949 if (!SWIG_IsOK(ecode2)) {
16950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16951 }
16952 arg2 = static_cast< int >(val2);
16953 ecode3 = SWIG_AsVal_int(obj2, &val3);
16954 if (!SWIG_IsOK(ecode3)) {
16955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16956 }
16957 arg3 = static_cast< int >(val3);
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16965 return resultobj;
16966 fail:
16967 return NULL;
16968 }
16969
16970
16971 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16972 PyObject *resultobj = 0;
16973 wxImage *arg1 = (wxImage *) 0 ;
16974 bool result;
16975 void *argp1 = 0 ;
16976 int res1 = 0 ;
16977 PyObject *swig_obj[1] ;
16978
16979 if (!args) SWIG_fail;
16980 swig_obj[0] = args;
16981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16982 if (!SWIG_IsOK(res1)) {
16983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16984 }
16985 arg1 = reinterpret_cast< wxImage * >(argp1);
16986 {
16987 PyThreadState* __tstate = wxPyBeginAllowThreads();
16988 result = (bool)(arg1)->HasAlpha();
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 {
16993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16994 }
16995 return resultobj;
16996 fail:
16997 return NULL;
16998 }
16999
17000
17001 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17002 PyObject *resultobj = 0;
17003 wxImage *arg1 = (wxImage *) 0 ;
17004 void *argp1 = 0 ;
17005 int res1 = 0 ;
17006 PyObject *swig_obj[1] ;
17007
17008 if (!args) SWIG_fail;
17009 swig_obj[0] = args;
17010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17011 if (!SWIG_IsOK(res1)) {
17012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17013 }
17014 arg1 = reinterpret_cast< wxImage * >(argp1);
17015 {
17016 PyThreadState* __tstate = wxPyBeginAllowThreads();
17017 (arg1)->InitAlpha();
17018 wxPyEndAllowThreads(__tstate);
17019 if (PyErr_Occurred()) SWIG_fail;
17020 }
17021 resultobj = SWIG_Py_Void();
17022 return resultobj;
17023 fail:
17024 return NULL;
17025 }
17026
17027
17028 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17029 PyObject *resultobj = 0;
17030 wxImage *arg1 = (wxImage *) 0 ;
17031 int arg2 ;
17032 int arg3 ;
17033 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17034 bool result;
17035 void *argp1 = 0 ;
17036 int res1 = 0 ;
17037 int val2 ;
17038 int ecode2 = 0 ;
17039 int val3 ;
17040 int ecode3 = 0 ;
17041 unsigned char val4 ;
17042 int ecode4 = 0 ;
17043 PyObject * obj0 = 0 ;
17044 PyObject * obj1 = 0 ;
17045 PyObject * obj2 = 0 ;
17046 PyObject * obj3 = 0 ;
17047 char * kwnames[] = {
17048 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17049 };
17050
17051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17053 if (!SWIG_IsOK(res1)) {
17054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17055 }
17056 arg1 = reinterpret_cast< wxImage * >(argp1);
17057 ecode2 = SWIG_AsVal_int(obj1, &val2);
17058 if (!SWIG_IsOK(ecode2)) {
17059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17060 }
17061 arg2 = static_cast< int >(val2);
17062 ecode3 = SWIG_AsVal_int(obj2, &val3);
17063 if (!SWIG_IsOK(ecode3)) {
17064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17065 }
17066 arg3 = static_cast< int >(val3);
17067 if (obj3) {
17068 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17069 if (!SWIG_IsOK(ecode4)) {
17070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17071 }
17072 arg4 = static_cast< byte >(val4);
17073 }
17074 {
17075 PyThreadState* __tstate = wxPyBeginAllowThreads();
17076 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17077 wxPyEndAllowThreads(__tstate);
17078 if (PyErr_Occurred()) SWIG_fail;
17079 }
17080 {
17081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17082 }
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17090 PyObject *resultobj = 0;
17091 wxImage *arg1 = (wxImage *) 0 ;
17092 byte *arg2 = (byte *) 0 ;
17093 byte *arg3 = (byte *) 0 ;
17094 byte *arg4 = (byte *) 0 ;
17095 byte arg5 = (byte) 0 ;
17096 byte arg6 = (byte) 0 ;
17097 byte arg7 = (byte) 0 ;
17098 bool result;
17099 void *argp1 = 0 ;
17100 int res1 = 0 ;
17101 byte temp2 ;
17102 int res2 = SWIG_TMPOBJ ;
17103 byte temp3 ;
17104 int res3 = SWIG_TMPOBJ ;
17105 byte temp4 ;
17106 int res4 = SWIG_TMPOBJ ;
17107 unsigned char val5 ;
17108 int ecode5 = 0 ;
17109 unsigned char val6 ;
17110 int ecode6 = 0 ;
17111 unsigned char val7 ;
17112 int ecode7 = 0 ;
17113 PyObject * obj0 = 0 ;
17114 PyObject * obj1 = 0 ;
17115 PyObject * obj2 = 0 ;
17116 PyObject * obj3 = 0 ;
17117 char * kwnames[] = {
17118 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17119 };
17120
17121 arg2 = &temp2;
17122 arg3 = &temp3;
17123 arg4 = &temp4;
17124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17126 if (!SWIG_IsOK(res1)) {
17127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17128 }
17129 arg1 = reinterpret_cast< wxImage * >(argp1);
17130 if (obj1) {
17131 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17132 if (!SWIG_IsOK(ecode5)) {
17133 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17134 }
17135 arg5 = static_cast< byte >(val5);
17136 }
17137 if (obj2) {
17138 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17139 if (!SWIG_IsOK(ecode6)) {
17140 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17141 }
17142 arg6 = static_cast< byte >(val6);
17143 }
17144 if (obj3) {
17145 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17146 if (!SWIG_IsOK(ecode7)) {
17147 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17148 }
17149 arg7 = static_cast< byte >(val7);
17150 }
17151 {
17152 PyThreadState* __tstate = wxPyBeginAllowThreads();
17153 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17154 wxPyEndAllowThreads(__tstate);
17155 if (PyErr_Occurred()) SWIG_fail;
17156 }
17157 {
17158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17159 }
17160 if (SWIG_IsTmpObj(res2)) {
17161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17162 } else {
17163 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17165 }
17166 if (SWIG_IsTmpObj(res3)) {
17167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17168 } else {
17169 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17171 }
17172 if (SWIG_IsTmpObj(res4)) {
17173 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17174 } else {
17175 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17176 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17177 }
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17185 PyObject *resultobj = 0;
17186 wxImage *arg1 = (wxImage *) 0 ;
17187 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17188 bool result;
17189 void *argp1 = 0 ;
17190 int res1 = 0 ;
17191 unsigned char val2 ;
17192 int ecode2 = 0 ;
17193 PyObject * obj0 = 0 ;
17194 PyObject * obj1 = 0 ;
17195 char * kwnames[] = {
17196 (char *) "self",(char *) "threshold", NULL
17197 };
17198
17199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17201 if (!SWIG_IsOK(res1)) {
17202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17203 }
17204 arg1 = reinterpret_cast< wxImage * >(argp1);
17205 if (obj1) {
17206 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17207 if (!SWIG_IsOK(ecode2)) {
17208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17209 }
17210 arg2 = static_cast< byte >(val2);
17211 }
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 {
17219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17220 }
17221 return resultobj;
17222 fail:
17223 return NULL;
17224 }
17225
17226
17227 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17228 PyObject *resultobj = 0;
17229 wxImage *arg1 = (wxImage *) 0 ;
17230 byte arg2 ;
17231 byte arg3 ;
17232 byte arg4 ;
17233 bool result;
17234 void *argp1 = 0 ;
17235 int res1 = 0 ;
17236 unsigned char val2 ;
17237 int ecode2 = 0 ;
17238 unsigned char val3 ;
17239 int ecode3 = 0 ;
17240 unsigned char val4 ;
17241 int ecode4 = 0 ;
17242 PyObject * obj0 = 0 ;
17243 PyObject * obj1 = 0 ;
17244 PyObject * obj2 = 0 ;
17245 PyObject * obj3 = 0 ;
17246 char * kwnames[] = {
17247 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17248 };
17249
17250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17252 if (!SWIG_IsOK(res1)) {
17253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17254 }
17255 arg1 = reinterpret_cast< wxImage * >(argp1);
17256 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17257 if (!SWIG_IsOK(ecode2)) {
17258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17259 }
17260 arg2 = static_cast< byte >(val2);
17261 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17262 if (!SWIG_IsOK(ecode3)) {
17263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17264 }
17265 arg3 = static_cast< byte >(val3);
17266 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17267 if (!SWIG_IsOK(ecode4)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17269 }
17270 arg4 = static_cast< byte >(val4);
17271 {
17272 PyThreadState* __tstate = wxPyBeginAllowThreads();
17273 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17274 wxPyEndAllowThreads(__tstate);
17275 if (PyErr_Occurred()) SWIG_fail;
17276 }
17277 {
17278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17279 }
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17287 PyObject *resultobj = 0;
17288 wxImage *arg1 = (wxImage *) 0 ;
17289 wxImage *arg2 = 0 ;
17290 byte arg3 ;
17291 byte arg4 ;
17292 byte arg5 ;
17293 bool result;
17294 void *argp1 = 0 ;
17295 int res1 = 0 ;
17296 void *argp2 = 0 ;
17297 int res2 = 0 ;
17298 unsigned char val3 ;
17299 int ecode3 = 0 ;
17300 unsigned char val4 ;
17301 int ecode4 = 0 ;
17302 unsigned char val5 ;
17303 int ecode5 = 0 ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 PyObject * obj2 = 0 ;
17307 PyObject * obj3 = 0 ;
17308 PyObject * obj4 = 0 ;
17309 char * kwnames[] = {
17310 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17311 };
17312
17313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17315 if (!SWIG_IsOK(res1)) {
17316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17317 }
17318 arg1 = reinterpret_cast< wxImage * >(argp1);
17319 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17320 if (!SWIG_IsOK(res2)) {
17321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17322 }
17323 if (!argp2) {
17324 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17325 }
17326 arg2 = reinterpret_cast< wxImage * >(argp2);
17327 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17328 if (!SWIG_IsOK(ecode3)) {
17329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17330 }
17331 arg3 = static_cast< byte >(val3);
17332 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17333 if (!SWIG_IsOK(ecode4)) {
17334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17335 }
17336 arg4 = static_cast< byte >(val4);
17337 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17338 if (!SWIG_IsOK(ecode5)) {
17339 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17340 }
17341 arg5 = static_cast< byte >(val5);
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17350 }
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj = 0;
17359 wxString *arg1 = 0 ;
17360 bool result;
17361 bool temp1 = false ;
17362 PyObject * obj0 = 0 ;
17363 char * kwnames[] = {
17364 (char *) "filename", NULL
17365 };
17366
17367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17368 {
17369 arg1 = wxString_in_helper(obj0);
17370 if (arg1 == NULL) SWIG_fail;
17371 temp1 = true;
17372 }
17373 {
17374 PyThreadState* __tstate = wxPyBeginAllowThreads();
17375 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17376 wxPyEndAllowThreads(__tstate);
17377 if (PyErr_Occurred()) SWIG_fail;
17378 }
17379 {
17380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17381 }
17382 {
17383 if (temp1)
17384 delete arg1;
17385 }
17386 return resultobj;
17387 fail:
17388 {
17389 if (temp1)
17390 delete arg1;
17391 }
17392 return NULL;
17393 }
17394
17395
17396 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17397 PyObject *resultobj = 0;
17398 wxString *arg1 = 0 ;
17399 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17400 int result;
17401 bool temp1 = false ;
17402 long val2 ;
17403 int ecode2 = 0 ;
17404 PyObject * obj0 = 0 ;
17405 PyObject * obj1 = 0 ;
17406 char * kwnames[] = {
17407 (char *) "filename",(char *) "type", NULL
17408 };
17409
17410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17411 {
17412 arg1 = wxString_in_helper(obj0);
17413 if (arg1 == NULL) SWIG_fail;
17414 temp1 = true;
17415 }
17416 if (obj1) {
17417 ecode2 = SWIG_AsVal_long(obj1, &val2);
17418 if (!SWIG_IsOK(ecode2)) {
17419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17420 }
17421 arg2 = static_cast< long >(val2);
17422 }
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17426 wxPyEndAllowThreads(__tstate);
17427 if (PyErr_Occurred()) SWIG_fail;
17428 }
17429 resultobj = SWIG_From_int(static_cast< int >(result));
17430 {
17431 if (temp1)
17432 delete arg1;
17433 }
17434 return resultobj;
17435 fail:
17436 {
17437 if (temp1)
17438 delete arg1;
17439 }
17440 return NULL;
17441 }
17442
17443
17444 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj = 0;
17446 wxImage *arg1 = (wxImage *) 0 ;
17447 wxString *arg2 = 0 ;
17448 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17449 int arg4 = (int) -1 ;
17450 bool result;
17451 void *argp1 = 0 ;
17452 int res1 = 0 ;
17453 bool temp2 = false ;
17454 long val3 ;
17455 int ecode3 = 0 ;
17456 int val4 ;
17457 int ecode4 = 0 ;
17458 PyObject * obj0 = 0 ;
17459 PyObject * obj1 = 0 ;
17460 PyObject * obj2 = 0 ;
17461 PyObject * obj3 = 0 ;
17462 char * kwnames[] = {
17463 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17464 };
17465
17466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17468 if (!SWIG_IsOK(res1)) {
17469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17470 }
17471 arg1 = reinterpret_cast< wxImage * >(argp1);
17472 {
17473 arg2 = wxString_in_helper(obj1);
17474 if (arg2 == NULL) SWIG_fail;
17475 temp2 = true;
17476 }
17477 if (obj2) {
17478 ecode3 = SWIG_AsVal_long(obj2, &val3);
17479 if (!SWIG_IsOK(ecode3)) {
17480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17481 }
17482 arg3 = static_cast< long >(val3);
17483 }
17484 if (obj3) {
17485 ecode4 = SWIG_AsVal_int(obj3, &val4);
17486 if (!SWIG_IsOK(ecode4)) {
17487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17488 }
17489 arg4 = static_cast< int >(val4);
17490 }
17491 {
17492 PyThreadState* __tstate = wxPyBeginAllowThreads();
17493 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 {
17498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17499 }
17500 {
17501 if (temp2)
17502 delete arg2;
17503 }
17504 return resultobj;
17505 fail:
17506 {
17507 if (temp2)
17508 delete arg2;
17509 }
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17515 PyObject *resultobj = 0;
17516 wxImage *arg1 = (wxImage *) 0 ;
17517 wxString *arg2 = 0 ;
17518 wxString *arg3 = 0 ;
17519 int arg4 = (int) -1 ;
17520 bool result;
17521 void *argp1 = 0 ;
17522 int res1 = 0 ;
17523 bool temp2 = false ;
17524 bool temp3 = false ;
17525 int val4 ;
17526 int ecode4 = 0 ;
17527 PyObject * obj0 = 0 ;
17528 PyObject * obj1 = 0 ;
17529 PyObject * obj2 = 0 ;
17530 PyObject * obj3 = 0 ;
17531 char * kwnames[] = {
17532 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17533 };
17534
17535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17537 if (!SWIG_IsOK(res1)) {
17538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17539 }
17540 arg1 = reinterpret_cast< wxImage * >(argp1);
17541 {
17542 arg2 = wxString_in_helper(obj1);
17543 if (arg2 == NULL) SWIG_fail;
17544 temp2 = true;
17545 }
17546 {
17547 arg3 = wxString_in_helper(obj2);
17548 if (arg3 == NULL) SWIG_fail;
17549 temp3 = true;
17550 }
17551 if (obj3) {
17552 ecode4 = SWIG_AsVal_int(obj3, &val4);
17553 if (!SWIG_IsOK(ecode4)) {
17554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17555 }
17556 arg4 = static_cast< int >(val4);
17557 }
17558 {
17559 PyThreadState* __tstate = wxPyBeginAllowThreads();
17560 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17561 wxPyEndAllowThreads(__tstate);
17562 if (PyErr_Occurred()) SWIG_fail;
17563 }
17564 {
17565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17566 }
17567 {
17568 if (temp2)
17569 delete arg2;
17570 }
17571 {
17572 if (temp3)
17573 delete arg3;
17574 }
17575 return resultobj;
17576 fail:
17577 {
17578 if (temp2)
17579 delete arg2;
17580 }
17581 {
17582 if (temp3)
17583 delete arg3;
17584 }
17585 return NULL;
17586 }
17587
17588
17589 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17590 PyObject *resultobj = 0;
17591 wxImage *arg1 = (wxImage *) 0 ;
17592 wxString *arg2 = 0 ;
17593 int arg3 ;
17594 bool result;
17595 void *argp1 = 0 ;
17596 int res1 = 0 ;
17597 bool temp2 = false ;
17598 int val3 ;
17599 int ecode3 = 0 ;
17600 PyObject * obj0 = 0 ;
17601 PyObject * obj1 = 0 ;
17602 PyObject * obj2 = 0 ;
17603 char * kwnames[] = {
17604 (char *) "self",(char *) "name",(char *) "type", NULL
17605 };
17606
17607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17609 if (!SWIG_IsOK(res1)) {
17610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17611 }
17612 arg1 = reinterpret_cast< wxImage * >(argp1);
17613 {
17614 arg2 = wxString_in_helper(obj1);
17615 if (arg2 == NULL) SWIG_fail;
17616 temp2 = true;
17617 }
17618 ecode3 = SWIG_AsVal_int(obj2, &val3);
17619 if (!SWIG_IsOK(ecode3)) {
17620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17621 }
17622 arg3 = static_cast< int >(val3);
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17631 }
17632 {
17633 if (temp2)
17634 delete arg2;
17635 }
17636 return resultobj;
17637 fail:
17638 {
17639 if (temp2)
17640 delete arg2;
17641 }
17642 return NULL;
17643 }
17644
17645
17646 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17647 PyObject *resultobj = 0;
17648 wxImage *arg1 = (wxImage *) 0 ;
17649 wxString *arg2 = 0 ;
17650 wxString *arg3 = 0 ;
17651 bool result;
17652 void *argp1 = 0 ;
17653 int res1 = 0 ;
17654 bool temp2 = false ;
17655 bool temp3 = false ;
17656 PyObject * obj0 = 0 ;
17657 PyObject * obj1 = 0 ;
17658 PyObject * obj2 = 0 ;
17659 char * kwnames[] = {
17660 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17661 };
17662
17663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17665 if (!SWIG_IsOK(res1)) {
17666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17667 }
17668 arg1 = reinterpret_cast< wxImage * >(argp1);
17669 {
17670 arg2 = wxString_in_helper(obj1);
17671 if (arg2 == NULL) SWIG_fail;
17672 temp2 = true;
17673 }
17674 {
17675 arg3 = wxString_in_helper(obj2);
17676 if (arg3 == NULL) SWIG_fail;
17677 temp3 = true;
17678 }
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 {
17686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17687 }
17688 {
17689 if (temp2)
17690 delete arg2;
17691 }
17692 {
17693 if (temp3)
17694 delete arg3;
17695 }
17696 return resultobj;
17697 fail:
17698 {
17699 if (temp2)
17700 delete arg2;
17701 }
17702 {
17703 if (temp3)
17704 delete arg3;
17705 }
17706 return NULL;
17707 }
17708
17709
17710 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17711 PyObject *resultobj = 0;
17712 wxInputStream *arg1 = 0 ;
17713 bool result;
17714 wxPyInputStream *temp1 ;
17715 bool created1 ;
17716 PyObject * obj0 = 0 ;
17717 char * kwnames[] = {
17718 (char *) "stream", NULL
17719 };
17720
17721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17722 {
17723 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17724 arg1 = temp1->m_wxis;
17725 created1 = false;
17726 } else {
17727 PyErr_Clear(); // clear the failure of the wxPyConvert above
17728 arg1 = wxPyCBInputStream_create(obj0, false);
17729 if (arg1 == NULL) {
17730 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17731 SWIG_fail;
17732 }
17733 created1 = true;
17734 }
17735 }
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (bool)wxImage::CanRead(*arg1);
17739 wxPyEndAllowThreads(__tstate);
17740 if (PyErr_Occurred()) SWIG_fail;
17741 }
17742 {
17743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17744 }
17745 {
17746 if (created1) delete arg1;
17747 }
17748 return resultobj;
17749 fail:
17750 {
17751 if (created1) delete arg1;
17752 }
17753 return NULL;
17754 }
17755
17756
17757 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17758 PyObject *resultobj = 0;
17759 wxImage *arg1 = (wxImage *) 0 ;
17760 wxInputStream *arg2 = 0 ;
17761 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17762 int arg4 = (int) -1 ;
17763 bool result;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 wxPyInputStream *temp2 ;
17767 bool created2 ;
17768 long val3 ;
17769 int ecode3 = 0 ;
17770 int val4 ;
17771 int ecode4 = 0 ;
17772 PyObject * obj0 = 0 ;
17773 PyObject * obj1 = 0 ;
17774 PyObject * obj2 = 0 ;
17775 PyObject * obj3 = 0 ;
17776 char * kwnames[] = {
17777 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17778 };
17779
17780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17784 }
17785 arg1 = reinterpret_cast< wxImage * >(argp1);
17786 {
17787 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17788 arg2 = temp2->m_wxis;
17789 created2 = false;
17790 } else {
17791 PyErr_Clear(); // clear the failure of the wxPyConvert above
17792 arg2 = wxPyCBInputStream_create(obj1, false);
17793 if (arg2 == NULL) {
17794 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17795 SWIG_fail;
17796 }
17797 created2 = true;
17798 }
17799 }
17800 if (obj2) {
17801 ecode3 = SWIG_AsVal_long(obj2, &val3);
17802 if (!SWIG_IsOK(ecode3)) {
17803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17804 }
17805 arg3 = static_cast< long >(val3);
17806 }
17807 if (obj3) {
17808 ecode4 = SWIG_AsVal_int(obj3, &val4);
17809 if (!SWIG_IsOK(ecode4)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17811 }
17812 arg4 = static_cast< int >(val4);
17813 }
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 {
17821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17822 }
17823 {
17824 if (created2) delete arg2;
17825 }
17826 return resultobj;
17827 fail:
17828 {
17829 if (created2) delete arg2;
17830 }
17831 return NULL;
17832 }
17833
17834
17835 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17836 PyObject *resultobj = 0;
17837 wxImage *arg1 = (wxImage *) 0 ;
17838 wxInputStream *arg2 = 0 ;
17839 wxString *arg3 = 0 ;
17840 int arg4 = (int) -1 ;
17841 bool result;
17842 void *argp1 = 0 ;
17843 int res1 = 0 ;
17844 wxPyInputStream *temp2 ;
17845 bool created2 ;
17846 bool temp3 = false ;
17847 int val4 ;
17848 int ecode4 = 0 ;
17849 PyObject * obj0 = 0 ;
17850 PyObject * obj1 = 0 ;
17851 PyObject * obj2 = 0 ;
17852 PyObject * obj3 = 0 ;
17853 char * kwnames[] = {
17854 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17855 };
17856
17857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17859 if (!SWIG_IsOK(res1)) {
17860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17861 }
17862 arg1 = reinterpret_cast< wxImage * >(argp1);
17863 {
17864 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17865 arg2 = temp2->m_wxis;
17866 created2 = false;
17867 } else {
17868 PyErr_Clear(); // clear the failure of the wxPyConvert above
17869 arg2 = wxPyCBInputStream_create(obj1, false);
17870 if (arg2 == NULL) {
17871 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17872 SWIG_fail;
17873 }
17874 created2 = true;
17875 }
17876 }
17877 {
17878 arg3 = wxString_in_helper(obj2);
17879 if (arg3 == NULL) SWIG_fail;
17880 temp3 = true;
17881 }
17882 if (obj3) {
17883 ecode4 = SWIG_AsVal_int(obj3, &val4);
17884 if (!SWIG_IsOK(ecode4)) {
17885 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17886 }
17887 arg4 = static_cast< int >(val4);
17888 }
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 {
17896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17897 }
17898 {
17899 if (created2) delete arg2;
17900 }
17901 {
17902 if (temp3)
17903 delete arg3;
17904 }
17905 return resultobj;
17906 fail:
17907 {
17908 if (created2) delete arg2;
17909 }
17910 {
17911 if (temp3)
17912 delete arg3;
17913 }
17914 return NULL;
17915 }
17916
17917
17918 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17919 PyObject *resultobj = 0;
17920 wxImage *arg1 = (wxImage *) 0 ;
17921 bool result;
17922 void *argp1 = 0 ;
17923 int res1 = 0 ;
17924 PyObject *swig_obj[1] ;
17925
17926 if (!args) SWIG_fail;
17927 swig_obj[0] = args;
17928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17929 if (!SWIG_IsOK(res1)) {
17930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17931 }
17932 arg1 = reinterpret_cast< wxImage * >(argp1);
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (bool)(arg1)->IsOk();
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17941 }
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17949 PyObject *resultobj = 0;
17950 wxImage *arg1 = (wxImage *) 0 ;
17951 int result;
17952 void *argp1 = 0 ;
17953 int res1 = 0 ;
17954 PyObject *swig_obj[1] ;
17955
17956 if (!args) SWIG_fail;
17957 swig_obj[0] = args;
17958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17959 if (!SWIG_IsOK(res1)) {
17960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17961 }
17962 arg1 = reinterpret_cast< wxImage * >(argp1);
17963 {
17964 PyThreadState* __tstate = wxPyBeginAllowThreads();
17965 result = (int)(arg1)->GetWidth();
17966 wxPyEndAllowThreads(__tstate);
17967 if (PyErr_Occurred()) SWIG_fail;
17968 }
17969 resultobj = SWIG_From_int(static_cast< int >(result));
17970 return resultobj;
17971 fail:
17972 return NULL;
17973 }
17974
17975
17976 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17977 PyObject *resultobj = 0;
17978 wxImage *arg1 = (wxImage *) 0 ;
17979 int result;
17980 void *argp1 = 0 ;
17981 int res1 = 0 ;
17982 PyObject *swig_obj[1] ;
17983
17984 if (!args) SWIG_fail;
17985 swig_obj[0] = args;
17986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17987 if (!SWIG_IsOK(res1)) {
17988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17989 }
17990 arg1 = reinterpret_cast< wxImage * >(argp1);
17991 {
17992 PyThreadState* __tstate = wxPyBeginAllowThreads();
17993 result = (int)(arg1)->GetHeight();
17994 wxPyEndAllowThreads(__tstate);
17995 if (PyErr_Occurred()) SWIG_fail;
17996 }
17997 resultobj = SWIG_From_int(static_cast< int >(result));
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18005 PyObject *resultobj = 0;
18006 wxImage *arg1 = (wxImage *) 0 ;
18007 wxSize result;
18008 void *argp1 = 0 ;
18009 int res1 = 0 ;
18010 PyObject *swig_obj[1] ;
18011
18012 if (!args) SWIG_fail;
18013 swig_obj[0] = args;
18014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18015 if (!SWIG_IsOK(res1)) {
18016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18017 }
18018 arg1 = reinterpret_cast< wxImage * >(argp1);
18019 {
18020 PyThreadState* __tstate = wxPyBeginAllowThreads();
18021 result = wxImage_GetSize(arg1);
18022 wxPyEndAllowThreads(__tstate);
18023 if (PyErr_Occurred()) SWIG_fail;
18024 }
18025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj = 0;
18034 wxImage *arg1 = (wxImage *) 0 ;
18035 wxRect *arg2 = 0 ;
18036 SwigValueWrapper<wxImage > result;
18037 void *argp1 = 0 ;
18038 int res1 = 0 ;
18039 wxRect temp2 ;
18040 PyObject * obj0 = 0 ;
18041 PyObject * obj1 = 0 ;
18042 char * kwnames[] = {
18043 (char *) "self",(char *) "rect", NULL
18044 };
18045
18046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18050 }
18051 arg1 = reinterpret_cast< wxImage * >(argp1);
18052 {
18053 arg2 = &temp2;
18054 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18055 }
18056 {
18057 PyThreadState* __tstate = wxPyBeginAllowThreads();
18058 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18059 wxPyEndAllowThreads(__tstate);
18060 if (PyErr_Occurred()) SWIG_fail;
18061 }
18062 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj = 0;
18071 wxImage *arg1 = (wxImage *) 0 ;
18072 wxSize *arg2 = 0 ;
18073 wxPoint *arg3 = 0 ;
18074 int arg4 = (int) -1 ;
18075 int arg5 = (int) -1 ;
18076 int arg6 = (int) -1 ;
18077 SwigValueWrapper<wxImage > result;
18078 void *argp1 = 0 ;
18079 int res1 = 0 ;
18080 wxSize temp2 ;
18081 wxPoint temp3 ;
18082 int val4 ;
18083 int ecode4 = 0 ;
18084 int val5 ;
18085 int ecode5 = 0 ;
18086 int val6 ;
18087 int ecode6 = 0 ;
18088 PyObject * obj0 = 0 ;
18089 PyObject * obj1 = 0 ;
18090 PyObject * obj2 = 0 ;
18091 PyObject * obj3 = 0 ;
18092 PyObject * obj4 = 0 ;
18093 PyObject * obj5 = 0 ;
18094 char * kwnames[] = {
18095 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18096 };
18097
18098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18100 if (!SWIG_IsOK(res1)) {
18101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18102 }
18103 arg1 = reinterpret_cast< wxImage * >(argp1);
18104 {
18105 arg2 = &temp2;
18106 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18107 }
18108 {
18109 arg3 = &temp3;
18110 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18111 }
18112 if (obj3) {
18113 ecode4 = SWIG_AsVal_int(obj3, &val4);
18114 if (!SWIG_IsOK(ecode4)) {
18115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18116 }
18117 arg4 = static_cast< int >(val4);
18118 }
18119 if (obj4) {
18120 ecode5 = SWIG_AsVal_int(obj4, &val5);
18121 if (!SWIG_IsOK(ecode5)) {
18122 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18123 }
18124 arg5 = static_cast< int >(val5);
18125 }
18126 if (obj5) {
18127 ecode6 = SWIG_AsVal_int(obj5, &val6);
18128 if (!SWIG_IsOK(ecode6)) {
18129 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18130 }
18131 arg6 = static_cast< int >(val6);
18132 }
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 PyObject *resultobj = 0;
18148 wxImage *arg1 = (wxImage *) 0 ;
18149 SwigValueWrapper<wxImage > result;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 PyObject *swig_obj[1] ;
18153
18154 if (!args) SWIG_fail;
18155 swig_obj[0] = args;
18156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18157 if (!SWIG_IsOK(res1)) {
18158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18159 }
18160 arg1 = reinterpret_cast< wxImage * >(argp1);
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 result = (arg1)->Copy();
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj = 0;
18176 wxImage *arg1 = (wxImage *) 0 ;
18177 wxImage *arg2 = 0 ;
18178 int arg3 ;
18179 int arg4 ;
18180 void *argp1 = 0 ;
18181 int res1 = 0 ;
18182 void *argp2 = 0 ;
18183 int res2 = 0 ;
18184 int val3 ;
18185 int ecode3 = 0 ;
18186 int val4 ;
18187 int ecode4 = 0 ;
18188 PyObject * obj0 = 0 ;
18189 PyObject * obj1 = 0 ;
18190 PyObject * obj2 = 0 ;
18191 PyObject * obj3 = 0 ;
18192 char * kwnames[] = {
18193 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18194 };
18195
18196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18198 if (!SWIG_IsOK(res1)) {
18199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18200 }
18201 arg1 = reinterpret_cast< wxImage * >(argp1);
18202 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18203 if (!SWIG_IsOK(res2)) {
18204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18205 }
18206 if (!argp2) {
18207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18208 }
18209 arg2 = reinterpret_cast< wxImage * >(argp2);
18210 ecode3 = SWIG_AsVal_int(obj2, &val3);
18211 if (!SWIG_IsOK(ecode3)) {
18212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18213 }
18214 arg3 = static_cast< int >(val3);
18215 ecode4 = SWIG_AsVal_int(obj3, &val4);
18216 if (!SWIG_IsOK(ecode4)) {
18217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18218 }
18219 arg4 = static_cast< int >(val4);
18220 {
18221 PyThreadState* __tstate = wxPyBeginAllowThreads();
18222 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 resultobj = SWIG_Py_Void();
18227 return resultobj;
18228 fail:
18229 return NULL;
18230 }
18231
18232
18233 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18234 PyObject *resultobj = 0;
18235 wxImage *arg1 = (wxImage *) 0 ;
18236 PyObject *result = 0 ;
18237 void *argp1 = 0 ;
18238 int res1 = 0 ;
18239 PyObject *swig_obj[1] ;
18240
18241 if (!args) SWIG_fail;
18242 swig_obj[0] = args;
18243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18244 if (!SWIG_IsOK(res1)) {
18245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18246 }
18247 arg1 = reinterpret_cast< wxImage * >(argp1);
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 result = (PyObject *)wxImage_GetData(arg1);
18251 wxPyEndAllowThreads(__tstate);
18252 if (PyErr_Occurred()) SWIG_fail;
18253 }
18254 resultobj = result;
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj = 0;
18263 wxImage *arg1 = (wxImage *) 0 ;
18264 buffer arg2 ;
18265 int arg3 ;
18266 void *argp1 = 0 ;
18267 int res1 = 0 ;
18268 Py_ssize_t temp2 ;
18269 PyObject * obj0 = 0 ;
18270 PyObject * obj1 = 0 ;
18271 char * kwnames[] = {
18272 (char *) "self",(char *) "data", NULL
18273 };
18274
18275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18279 }
18280 arg1 = reinterpret_cast< wxImage * >(argp1);
18281 {
18282 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18283 arg3 = (int)temp2;
18284 }
18285 {
18286 PyThreadState* __tstate = wxPyBeginAllowThreads();
18287 wxImage_SetData(arg1,arg2,arg3);
18288 wxPyEndAllowThreads(__tstate);
18289 if (PyErr_Occurred()) SWIG_fail;
18290 }
18291 resultobj = SWIG_Py_Void();
18292 return resultobj;
18293 fail:
18294 return NULL;
18295 }
18296
18297
18298 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18299 PyObject *resultobj = 0;
18300 wxImage *arg1 = (wxImage *) 0 ;
18301 PyObject *result = 0 ;
18302 void *argp1 = 0 ;
18303 int res1 = 0 ;
18304 PyObject *swig_obj[1] ;
18305
18306 if (!args) SWIG_fail;
18307 swig_obj[0] = args;
18308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18309 if (!SWIG_IsOK(res1)) {
18310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18311 }
18312 arg1 = reinterpret_cast< wxImage * >(argp1);
18313 {
18314 PyThreadState* __tstate = wxPyBeginAllowThreads();
18315 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18316 wxPyEndAllowThreads(__tstate);
18317 if (PyErr_Occurred()) SWIG_fail;
18318 }
18319 resultobj = result;
18320 return resultobj;
18321 fail:
18322 return NULL;
18323 }
18324
18325
18326 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18327 PyObject *resultobj = 0;
18328 wxImage *arg1 = (wxImage *) 0 ;
18329 buffer arg2 ;
18330 int arg3 ;
18331 void *argp1 = 0 ;
18332 int res1 = 0 ;
18333 Py_ssize_t temp2 ;
18334 PyObject * obj0 = 0 ;
18335 PyObject * obj1 = 0 ;
18336 char * kwnames[] = {
18337 (char *) "self",(char *) "data", NULL
18338 };
18339
18340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18344 }
18345 arg1 = reinterpret_cast< wxImage * >(argp1);
18346 {
18347 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18348 arg3 = (int)temp2;
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 wxImage_SetDataBuffer(arg1,arg2,arg3);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 resultobj = SWIG_Py_Void();
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18364 PyObject *resultobj = 0;
18365 wxImage *arg1 = (wxImage *) 0 ;
18366 PyObject *result = 0 ;
18367 void *argp1 = 0 ;
18368 int res1 = 0 ;
18369 PyObject *swig_obj[1] ;
18370
18371 if (!args) SWIG_fail;
18372 swig_obj[0] = args;
18373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18374 if (!SWIG_IsOK(res1)) {
18375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18376 }
18377 arg1 = reinterpret_cast< wxImage * >(argp1);
18378 {
18379 PyThreadState* __tstate = wxPyBeginAllowThreads();
18380 result = (PyObject *)wxImage_GetAlphaData(arg1);
18381 wxPyEndAllowThreads(__tstate);
18382 if (PyErr_Occurred()) SWIG_fail;
18383 }
18384 resultobj = result;
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18392 PyObject *resultobj = 0;
18393 wxImage *arg1 = (wxImage *) 0 ;
18394 buffer arg2 ;
18395 int arg3 ;
18396 void *argp1 = 0 ;
18397 int res1 = 0 ;
18398 Py_ssize_t temp2 ;
18399 PyObject * obj0 = 0 ;
18400 PyObject * obj1 = 0 ;
18401 char * kwnames[] = {
18402 (char *) "self",(char *) "alpha", NULL
18403 };
18404
18405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18407 if (!SWIG_IsOK(res1)) {
18408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18409 }
18410 arg1 = reinterpret_cast< wxImage * >(argp1);
18411 {
18412 if (obj1 != Py_None) {
18413 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18414 arg3 = (int)temp2;
18415 }
18416 }
18417 {
18418 PyThreadState* __tstate = wxPyBeginAllowThreads();
18419 wxImage_SetAlphaData(arg1,arg2,arg3);
18420 wxPyEndAllowThreads(__tstate);
18421 if (PyErr_Occurred()) SWIG_fail;
18422 }
18423 resultobj = SWIG_Py_Void();
18424 return resultobj;
18425 fail:
18426 return NULL;
18427 }
18428
18429
18430 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18431 PyObject *resultobj = 0;
18432 wxImage *arg1 = (wxImage *) 0 ;
18433 PyObject *result = 0 ;
18434 void *argp1 = 0 ;
18435 int res1 = 0 ;
18436 PyObject *swig_obj[1] ;
18437
18438 if (!args) SWIG_fail;
18439 swig_obj[0] = args;
18440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18441 if (!SWIG_IsOK(res1)) {
18442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18443 }
18444 arg1 = reinterpret_cast< wxImage * >(argp1);
18445 {
18446 PyThreadState* __tstate = wxPyBeginAllowThreads();
18447 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18448 wxPyEndAllowThreads(__tstate);
18449 if (PyErr_Occurred()) SWIG_fail;
18450 }
18451 resultobj = result;
18452 return resultobj;
18453 fail:
18454 return NULL;
18455 }
18456
18457
18458 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18459 PyObject *resultobj = 0;
18460 wxImage *arg1 = (wxImage *) 0 ;
18461 buffer arg2 ;
18462 int arg3 ;
18463 void *argp1 = 0 ;
18464 int res1 = 0 ;
18465 Py_ssize_t temp2 ;
18466 PyObject * obj0 = 0 ;
18467 PyObject * obj1 = 0 ;
18468 char * kwnames[] = {
18469 (char *) "self",(char *) "alpha", NULL
18470 };
18471
18472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18474 if (!SWIG_IsOK(res1)) {
18475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18476 }
18477 arg1 = reinterpret_cast< wxImage * >(argp1);
18478 {
18479 if (obj1 != Py_None) {
18480 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18481 arg3 = (int)temp2;
18482 }
18483 }
18484 {
18485 PyThreadState* __tstate = wxPyBeginAllowThreads();
18486 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 resultobj = SWIG_Py_Void();
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18498 PyObject *resultobj = 0;
18499 wxImage *arg1 = (wxImage *) 0 ;
18500 byte arg2 ;
18501 byte arg3 ;
18502 byte arg4 ;
18503 void *argp1 = 0 ;
18504 int res1 = 0 ;
18505 unsigned char val2 ;
18506 int ecode2 = 0 ;
18507 unsigned char val3 ;
18508 int ecode3 = 0 ;
18509 unsigned char val4 ;
18510 int ecode4 = 0 ;
18511 PyObject * obj0 = 0 ;
18512 PyObject * obj1 = 0 ;
18513 PyObject * obj2 = 0 ;
18514 PyObject * obj3 = 0 ;
18515 char * kwnames[] = {
18516 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18517 };
18518
18519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18521 if (!SWIG_IsOK(res1)) {
18522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18523 }
18524 arg1 = reinterpret_cast< wxImage * >(argp1);
18525 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18526 if (!SWIG_IsOK(ecode2)) {
18527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18528 }
18529 arg2 = static_cast< byte >(val2);
18530 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18531 if (!SWIG_IsOK(ecode3)) {
18532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18533 }
18534 arg3 = static_cast< byte >(val3);
18535 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18536 if (!SWIG_IsOK(ecode4)) {
18537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18538 }
18539 arg4 = static_cast< byte >(val4);
18540 {
18541 PyThreadState* __tstate = wxPyBeginAllowThreads();
18542 (arg1)->SetMaskColour(arg2,arg3,arg4);
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 resultobj = SWIG_Py_Void();
18547 return resultobj;
18548 fail:
18549 return NULL;
18550 }
18551
18552
18553 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18554 PyObject *resultobj = 0;
18555 wxImage *arg1 = (wxImage *) 0 ;
18556 byte *arg2 = (byte *) 0 ;
18557 byte *arg3 = (byte *) 0 ;
18558 byte *arg4 = (byte *) 0 ;
18559 void *argp1 = 0 ;
18560 int res1 = 0 ;
18561 byte temp2 ;
18562 int res2 = SWIG_TMPOBJ ;
18563 byte temp3 ;
18564 int res3 = SWIG_TMPOBJ ;
18565 byte temp4 ;
18566 int res4 = SWIG_TMPOBJ ;
18567 PyObject *swig_obj[1] ;
18568
18569 arg2 = &temp2;
18570 arg3 = &temp3;
18571 arg4 = &temp4;
18572 if (!args) SWIG_fail;
18573 swig_obj[0] = args;
18574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18577 }
18578 arg1 = reinterpret_cast< wxImage * >(argp1);
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 resultobj = SWIG_Py_Void();
18586 if (SWIG_IsTmpObj(res2)) {
18587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18588 } else {
18589 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18591 }
18592 if (SWIG_IsTmpObj(res3)) {
18593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18594 } else {
18595 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18597 }
18598 if (SWIG_IsTmpObj(res4)) {
18599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18600 } else {
18601 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18603 }
18604 return resultobj;
18605 fail:
18606 return NULL;
18607 }
18608
18609
18610 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18611 PyObject *resultobj = 0;
18612 wxImage *arg1 = (wxImage *) 0 ;
18613 byte result;
18614 void *argp1 = 0 ;
18615 int res1 = 0 ;
18616 PyObject *swig_obj[1] ;
18617
18618 if (!args) SWIG_fail;
18619 swig_obj[0] = args;
18620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18623 }
18624 arg1 = reinterpret_cast< wxImage * >(argp1);
18625 {
18626 PyThreadState* __tstate = wxPyBeginAllowThreads();
18627 result = (byte)(arg1)->GetMaskRed();
18628 wxPyEndAllowThreads(__tstate);
18629 if (PyErr_Occurred()) SWIG_fail;
18630 }
18631 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18632 return resultobj;
18633 fail:
18634 return NULL;
18635 }
18636
18637
18638 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18639 PyObject *resultobj = 0;
18640 wxImage *arg1 = (wxImage *) 0 ;
18641 byte result;
18642 void *argp1 = 0 ;
18643 int res1 = 0 ;
18644 PyObject *swig_obj[1] ;
18645
18646 if (!args) SWIG_fail;
18647 swig_obj[0] = args;
18648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18649 if (!SWIG_IsOK(res1)) {
18650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18651 }
18652 arg1 = reinterpret_cast< wxImage * >(argp1);
18653 {
18654 PyThreadState* __tstate = wxPyBeginAllowThreads();
18655 result = (byte)(arg1)->GetMaskGreen();
18656 wxPyEndAllowThreads(__tstate);
18657 if (PyErr_Occurred()) SWIG_fail;
18658 }
18659 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18660 return resultobj;
18661 fail:
18662 return NULL;
18663 }
18664
18665
18666 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18667 PyObject *resultobj = 0;
18668 wxImage *arg1 = (wxImage *) 0 ;
18669 byte result;
18670 void *argp1 = 0 ;
18671 int res1 = 0 ;
18672 PyObject *swig_obj[1] ;
18673
18674 if (!args) SWIG_fail;
18675 swig_obj[0] = args;
18676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18677 if (!SWIG_IsOK(res1)) {
18678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18679 }
18680 arg1 = reinterpret_cast< wxImage * >(argp1);
18681 {
18682 PyThreadState* __tstate = wxPyBeginAllowThreads();
18683 result = (byte)(arg1)->GetMaskBlue();
18684 wxPyEndAllowThreads(__tstate);
18685 if (PyErr_Occurred()) SWIG_fail;
18686 }
18687 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18688 return resultobj;
18689 fail:
18690 return NULL;
18691 }
18692
18693
18694 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18695 PyObject *resultobj = 0;
18696 wxImage *arg1 = (wxImage *) 0 ;
18697 bool arg2 = (bool) true ;
18698 void *argp1 = 0 ;
18699 int res1 = 0 ;
18700 bool val2 ;
18701 int ecode2 = 0 ;
18702 PyObject * obj0 = 0 ;
18703 PyObject * obj1 = 0 ;
18704 char * kwnames[] = {
18705 (char *) "self",(char *) "mask", NULL
18706 };
18707
18708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18710 if (!SWIG_IsOK(res1)) {
18711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18712 }
18713 arg1 = reinterpret_cast< wxImage * >(argp1);
18714 if (obj1) {
18715 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18716 if (!SWIG_IsOK(ecode2)) {
18717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18718 }
18719 arg2 = static_cast< bool >(val2);
18720 }
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 (arg1)->SetMask(arg2);
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 resultobj = SWIG_Py_Void();
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18735 PyObject *resultobj = 0;
18736 wxImage *arg1 = (wxImage *) 0 ;
18737 bool result;
18738 void *argp1 = 0 ;
18739 int res1 = 0 ;
18740 PyObject *swig_obj[1] ;
18741
18742 if (!args) SWIG_fail;
18743 swig_obj[0] = args;
18744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18745 if (!SWIG_IsOK(res1)) {
18746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18747 }
18748 arg1 = reinterpret_cast< wxImage * >(argp1);
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 result = (bool)(arg1)->HasMask();
18752 wxPyEndAllowThreads(__tstate);
18753 if (PyErr_Occurred()) SWIG_fail;
18754 }
18755 {
18756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18757 }
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18765 PyObject *resultobj = 0;
18766 wxImage *arg1 = (wxImage *) 0 ;
18767 double arg2 ;
18768 wxPoint *arg3 = 0 ;
18769 bool arg4 = (bool) true ;
18770 wxPoint *arg5 = (wxPoint *) NULL ;
18771 SwigValueWrapper<wxImage > result;
18772 void *argp1 = 0 ;
18773 int res1 = 0 ;
18774 double val2 ;
18775 int ecode2 = 0 ;
18776 wxPoint temp3 ;
18777 bool val4 ;
18778 int ecode4 = 0 ;
18779 void *argp5 = 0 ;
18780 int res5 = 0 ;
18781 PyObject * obj0 = 0 ;
18782 PyObject * obj1 = 0 ;
18783 PyObject * obj2 = 0 ;
18784 PyObject * obj3 = 0 ;
18785 PyObject * obj4 = 0 ;
18786 char * kwnames[] = {
18787 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18788 };
18789
18790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18794 }
18795 arg1 = reinterpret_cast< wxImage * >(argp1);
18796 ecode2 = SWIG_AsVal_double(obj1, &val2);
18797 if (!SWIG_IsOK(ecode2)) {
18798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18799 }
18800 arg2 = static_cast< double >(val2);
18801 {
18802 arg3 = &temp3;
18803 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18804 }
18805 if (obj3) {
18806 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18807 if (!SWIG_IsOK(ecode4)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18809 }
18810 arg4 = static_cast< bool >(val4);
18811 }
18812 if (obj4) {
18813 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18814 if (!SWIG_IsOK(res5)) {
18815 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18816 }
18817 arg5 = reinterpret_cast< wxPoint * >(argp5);
18818 }
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18822 wxPyEndAllowThreads(__tstate);
18823 if (PyErr_Occurred()) SWIG_fail;
18824 }
18825 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18826 return resultobj;
18827 fail:
18828 return NULL;
18829 }
18830
18831
18832 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18833 PyObject *resultobj = 0;
18834 wxImage *arg1 = (wxImage *) 0 ;
18835 bool arg2 = (bool) true ;
18836 SwigValueWrapper<wxImage > result;
18837 void *argp1 = 0 ;
18838 int res1 = 0 ;
18839 bool val2 ;
18840 int ecode2 = 0 ;
18841 PyObject * obj0 = 0 ;
18842 PyObject * obj1 = 0 ;
18843 char * kwnames[] = {
18844 (char *) "self",(char *) "clockwise", NULL
18845 };
18846
18847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18849 if (!SWIG_IsOK(res1)) {
18850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18851 }
18852 arg1 = reinterpret_cast< wxImage * >(argp1);
18853 if (obj1) {
18854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18855 if (!SWIG_IsOK(ecode2)) {
18856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18857 }
18858 arg2 = static_cast< bool >(val2);
18859 }
18860 {
18861 PyThreadState* __tstate = wxPyBeginAllowThreads();
18862 result = (arg1)->Rotate90(arg2);
18863 wxPyEndAllowThreads(__tstate);
18864 if (PyErr_Occurred()) SWIG_fail;
18865 }
18866 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18867 return resultobj;
18868 fail:
18869 return NULL;
18870 }
18871
18872
18873 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18874 PyObject *resultobj = 0;
18875 wxImage *arg1 = (wxImage *) 0 ;
18876 bool arg2 = (bool) true ;
18877 SwigValueWrapper<wxImage > result;
18878 void *argp1 = 0 ;
18879 int res1 = 0 ;
18880 bool val2 ;
18881 int ecode2 = 0 ;
18882 PyObject * obj0 = 0 ;
18883 PyObject * obj1 = 0 ;
18884 char * kwnames[] = {
18885 (char *) "self",(char *) "horizontally", NULL
18886 };
18887
18888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18890 if (!SWIG_IsOK(res1)) {
18891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18892 }
18893 arg1 = reinterpret_cast< wxImage * >(argp1);
18894 if (obj1) {
18895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18896 if (!SWIG_IsOK(ecode2)) {
18897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18898 }
18899 arg2 = static_cast< bool >(val2);
18900 }
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 result = (arg1)->Mirror(arg2);
18904 wxPyEndAllowThreads(__tstate);
18905 if (PyErr_Occurred()) SWIG_fail;
18906 }
18907 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18908 return resultobj;
18909 fail:
18910 return NULL;
18911 }
18912
18913
18914 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18915 PyObject *resultobj = 0;
18916 wxImage *arg1 = (wxImage *) 0 ;
18917 byte arg2 ;
18918 byte arg3 ;
18919 byte arg4 ;
18920 byte arg5 ;
18921 byte arg6 ;
18922 byte arg7 ;
18923 void *argp1 = 0 ;
18924 int res1 = 0 ;
18925 unsigned char val2 ;
18926 int ecode2 = 0 ;
18927 unsigned char val3 ;
18928 int ecode3 = 0 ;
18929 unsigned char val4 ;
18930 int ecode4 = 0 ;
18931 unsigned char val5 ;
18932 int ecode5 = 0 ;
18933 unsigned char val6 ;
18934 int ecode6 = 0 ;
18935 unsigned char val7 ;
18936 int ecode7 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 PyObject * obj2 = 0 ;
18940 PyObject * obj3 = 0 ;
18941 PyObject * obj4 = 0 ;
18942 PyObject * obj5 = 0 ;
18943 PyObject * obj6 = 0 ;
18944 char * kwnames[] = {
18945 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18946 };
18947
18948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18952 }
18953 arg1 = reinterpret_cast< wxImage * >(argp1);
18954 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18955 if (!SWIG_IsOK(ecode2)) {
18956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18957 }
18958 arg2 = static_cast< byte >(val2);
18959 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18960 if (!SWIG_IsOK(ecode3)) {
18961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18962 }
18963 arg3 = static_cast< byte >(val3);
18964 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18965 if (!SWIG_IsOK(ecode4)) {
18966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18967 }
18968 arg4 = static_cast< byte >(val4);
18969 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18970 if (!SWIG_IsOK(ecode5)) {
18971 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18972 }
18973 arg5 = static_cast< byte >(val5);
18974 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18975 if (!SWIG_IsOK(ecode6)) {
18976 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18977 }
18978 arg6 = static_cast< byte >(val6);
18979 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18980 if (!SWIG_IsOK(ecode7)) {
18981 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18982 }
18983 arg7 = static_cast< byte >(val7);
18984 {
18985 PyThreadState* __tstate = wxPyBeginAllowThreads();
18986 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18987 wxPyEndAllowThreads(__tstate);
18988 if (PyErr_Occurred()) SWIG_fail;
18989 }
18990 resultobj = SWIG_Py_Void();
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj = 0;
18999 wxImage *arg1 = (wxImage *) 0 ;
19000 double arg2 = (double) 0.299 ;
19001 double arg3 = (double) 0.587 ;
19002 double arg4 = (double) 0.114 ;
19003 SwigValueWrapper<wxImage > result;
19004 void *argp1 = 0 ;
19005 int res1 = 0 ;
19006 double val2 ;
19007 int ecode2 = 0 ;
19008 double val3 ;
19009 int ecode3 = 0 ;
19010 double val4 ;
19011 int ecode4 = 0 ;
19012 PyObject * obj0 = 0 ;
19013 PyObject * obj1 = 0 ;
19014 PyObject * obj2 = 0 ;
19015 PyObject * obj3 = 0 ;
19016 char * kwnames[] = {
19017 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19018 };
19019
19020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19022 if (!SWIG_IsOK(res1)) {
19023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19024 }
19025 arg1 = reinterpret_cast< wxImage * >(argp1);
19026 if (obj1) {
19027 ecode2 = SWIG_AsVal_double(obj1, &val2);
19028 if (!SWIG_IsOK(ecode2)) {
19029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19030 }
19031 arg2 = static_cast< double >(val2);
19032 }
19033 if (obj2) {
19034 ecode3 = SWIG_AsVal_double(obj2, &val3);
19035 if (!SWIG_IsOK(ecode3)) {
19036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19037 }
19038 arg3 = static_cast< double >(val3);
19039 }
19040 if (obj3) {
19041 ecode4 = SWIG_AsVal_double(obj3, &val4);
19042 if (!SWIG_IsOK(ecode4)) {
19043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19044 }
19045 arg4 = static_cast< double >(val4);
19046 }
19047 {
19048 PyThreadState* __tstate = wxPyBeginAllowThreads();
19049 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19050 wxPyEndAllowThreads(__tstate);
19051 if (PyErr_Occurred()) SWIG_fail;
19052 }
19053 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19054 return resultobj;
19055 fail:
19056 return NULL;
19057 }
19058
19059
19060 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19061 PyObject *resultobj = 0;
19062 wxImage *arg1 = (wxImage *) 0 ;
19063 byte arg2 ;
19064 byte arg3 ;
19065 byte arg4 ;
19066 SwigValueWrapper<wxImage > result;
19067 void *argp1 = 0 ;
19068 int res1 = 0 ;
19069 unsigned char val2 ;
19070 int ecode2 = 0 ;
19071 unsigned char val3 ;
19072 int ecode3 = 0 ;
19073 unsigned char val4 ;
19074 int ecode4 = 0 ;
19075 PyObject * obj0 = 0 ;
19076 PyObject * obj1 = 0 ;
19077 PyObject * obj2 = 0 ;
19078 PyObject * obj3 = 0 ;
19079 char * kwnames[] = {
19080 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19081 };
19082
19083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19085 if (!SWIG_IsOK(res1)) {
19086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19087 }
19088 arg1 = reinterpret_cast< wxImage * >(argp1);
19089 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19090 if (!SWIG_IsOK(ecode2)) {
19091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19092 }
19093 arg2 = static_cast< byte >(val2);
19094 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19095 if (!SWIG_IsOK(ecode3)) {
19096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19097 }
19098 arg3 = static_cast< byte >(val3);
19099 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19100 if (!SWIG_IsOK(ecode4)) {
19101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19102 }
19103 arg4 = static_cast< byte >(val4);
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj = 0;
19119 wxImage *arg1 = (wxImage *) 0 ;
19120 wxString *arg2 = 0 ;
19121 wxString *arg3 = 0 ;
19122 void *argp1 = 0 ;
19123 int res1 = 0 ;
19124 bool temp2 = false ;
19125 bool temp3 = false ;
19126 PyObject * obj0 = 0 ;
19127 PyObject * obj1 = 0 ;
19128 PyObject * obj2 = 0 ;
19129 char * kwnames[] = {
19130 (char *) "self",(char *) "name",(char *) "value", NULL
19131 };
19132
19133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19135 if (!SWIG_IsOK(res1)) {
19136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19137 }
19138 arg1 = reinterpret_cast< wxImage * >(argp1);
19139 {
19140 arg2 = wxString_in_helper(obj1);
19141 if (arg2 == NULL) SWIG_fail;
19142 temp2 = true;
19143 }
19144 {
19145 arg3 = wxString_in_helper(obj2);
19146 if (arg3 == NULL) SWIG_fail;
19147 temp3 = true;
19148 }
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_Py_Void();
19156 {
19157 if (temp2)
19158 delete arg2;
19159 }
19160 {
19161 if (temp3)
19162 delete arg3;
19163 }
19164 return resultobj;
19165 fail:
19166 {
19167 if (temp2)
19168 delete arg2;
19169 }
19170 {
19171 if (temp3)
19172 delete arg3;
19173 }
19174 return NULL;
19175 }
19176
19177
19178 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19179 PyObject *resultobj = 0;
19180 wxImage *arg1 = (wxImage *) 0 ;
19181 wxString *arg2 = 0 ;
19182 int arg3 ;
19183 void *argp1 = 0 ;
19184 int res1 = 0 ;
19185 bool temp2 = false ;
19186 int val3 ;
19187 int ecode3 = 0 ;
19188 PyObject * obj0 = 0 ;
19189 PyObject * obj1 = 0 ;
19190 PyObject * obj2 = 0 ;
19191 char * kwnames[] = {
19192 (char *) "self",(char *) "name",(char *) "value", NULL
19193 };
19194
19195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19197 if (!SWIG_IsOK(res1)) {
19198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19199 }
19200 arg1 = reinterpret_cast< wxImage * >(argp1);
19201 {
19202 arg2 = wxString_in_helper(obj1);
19203 if (arg2 == NULL) SWIG_fail;
19204 temp2 = true;
19205 }
19206 ecode3 = SWIG_AsVal_int(obj2, &val3);
19207 if (!SWIG_IsOK(ecode3)) {
19208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19209 }
19210 arg3 = static_cast< int >(val3);
19211 {
19212 PyThreadState* __tstate = wxPyBeginAllowThreads();
19213 (arg1)->SetOption((wxString const &)*arg2,arg3);
19214 wxPyEndAllowThreads(__tstate);
19215 if (PyErr_Occurred()) SWIG_fail;
19216 }
19217 resultobj = SWIG_Py_Void();
19218 {
19219 if (temp2)
19220 delete arg2;
19221 }
19222 return resultobj;
19223 fail:
19224 {
19225 if (temp2)
19226 delete arg2;
19227 }
19228 return NULL;
19229 }
19230
19231
19232 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19233 PyObject *resultobj = 0;
19234 wxImage *arg1 = (wxImage *) 0 ;
19235 wxString *arg2 = 0 ;
19236 wxString result;
19237 void *argp1 = 0 ;
19238 int res1 = 0 ;
19239 bool temp2 = false ;
19240 PyObject * obj0 = 0 ;
19241 PyObject * obj1 = 0 ;
19242 char * kwnames[] = {
19243 (char *) "self",(char *) "name", NULL
19244 };
19245
19246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19248 if (!SWIG_IsOK(res1)) {
19249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19250 }
19251 arg1 = reinterpret_cast< wxImage * >(argp1);
19252 {
19253 arg2 = wxString_in_helper(obj1);
19254 if (arg2 == NULL) SWIG_fail;
19255 temp2 = true;
19256 }
19257 {
19258 PyThreadState* __tstate = wxPyBeginAllowThreads();
19259 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 {
19264 #if wxUSE_UNICODE
19265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19266 #else
19267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19268 #endif
19269 }
19270 {
19271 if (temp2)
19272 delete arg2;
19273 }
19274 return resultobj;
19275 fail:
19276 {
19277 if (temp2)
19278 delete arg2;
19279 }
19280 return NULL;
19281 }
19282
19283
19284 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj = 0;
19286 wxImage *arg1 = (wxImage *) 0 ;
19287 wxString *arg2 = 0 ;
19288 int result;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 bool temp2 = false ;
19292 PyObject * obj0 = 0 ;
19293 PyObject * obj1 = 0 ;
19294 char * kwnames[] = {
19295 (char *) "self",(char *) "name", NULL
19296 };
19297
19298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19302 }
19303 arg1 = reinterpret_cast< wxImage * >(argp1);
19304 {
19305 arg2 = wxString_in_helper(obj1);
19306 if (arg2 == NULL) SWIG_fail;
19307 temp2 = true;
19308 }
19309 {
19310 PyThreadState* __tstate = wxPyBeginAllowThreads();
19311 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 resultobj = SWIG_From_int(static_cast< int >(result));
19316 {
19317 if (temp2)
19318 delete arg2;
19319 }
19320 return resultobj;
19321 fail:
19322 {
19323 if (temp2)
19324 delete arg2;
19325 }
19326 return NULL;
19327 }
19328
19329
19330 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19331 PyObject *resultobj = 0;
19332 wxImage *arg1 = (wxImage *) 0 ;
19333 wxString *arg2 = 0 ;
19334 bool result;
19335 void *argp1 = 0 ;
19336 int res1 = 0 ;
19337 bool temp2 = false ;
19338 PyObject * obj0 = 0 ;
19339 PyObject * obj1 = 0 ;
19340 char * kwnames[] = {
19341 (char *) "self",(char *) "name", NULL
19342 };
19343
19344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19346 if (!SWIG_IsOK(res1)) {
19347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19348 }
19349 arg1 = reinterpret_cast< wxImage * >(argp1);
19350 {
19351 arg2 = wxString_in_helper(obj1);
19352 if (arg2 == NULL) SWIG_fail;
19353 temp2 = true;
19354 }
19355 {
19356 PyThreadState* __tstate = wxPyBeginAllowThreads();
19357 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 {
19362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19363 }
19364 {
19365 if (temp2)
19366 delete arg2;
19367 }
19368 return resultobj;
19369 fail:
19370 {
19371 if (temp2)
19372 delete arg2;
19373 }
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj = 0;
19380 wxImage *arg1 = (wxImage *) 0 ;
19381 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19382 unsigned long result;
19383 void *argp1 = 0 ;
19384 int res1 = 0 ;
19385 unsigned long val2 ;
19386 int ecode2 = 0 ;
19387 PyObject * obj0 = 0 ;
19388 PyObject * obj1 = 0 ;
19389 char * kwnames[] = {
19390 (char *) "self",(char *) "stopafter", NULL
19391 };
19392
19393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19395 if (!SWIG_IsOK(res1)) {
19396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19397 }
19398 arg1 = reinterpret_cast< wxImage * >(argp1);
19399 if (obj1) {
19400 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19401 if (!SWIG_IsOK(ecode2)) {
19402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19403 }
19404 arg2 = static_cast< unsigned long >(val2);
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (unsigned long)(arg1)->CountColours(arg2);
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = 0;
19421 wxImage *arg1 = (wxImage *) 0 ;
19422 wxImageHistogram *arg2 = 0 ;
19423 unsigned long result;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 void *argp2 = 0 ;
19427 int res2 = 0 ;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char * kwnames[] = {
19431 (char *) "self",(char *) "h", NULL
19432 };
19433
19434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19438 }
19439 arg1 = reinterpret_cast< wxImage * >(argp1);
19440 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19441 if (!SWIG_IsOK(res2)) {
19442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19443 }
19444 if (!argp2) {
19445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19446 }
19447 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19455 return resultobj;
19456 fail:
19457 return NULL;
19458 }
19459
19460
19461 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19462 PyObject *resultobj = 0;
19463 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19464 void *argp1 = 0 ;
19465 int res1 = 0 ;
19466 PyObject * obj0 = 0 ;
19467 char * kwnames[] = {
19468 (char *) "handler", NULL
19469 };
19470
19471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19473 if (!SWIG_IsOK(res1)) {
19474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19475 }
19476 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19477 {
19478 PyThreadState* __tstate = wxPyBeginAllowThreads();
19479 wxImage::AddHandler(arg1);
19480 wxPyEndAllowThreads(__tstate);
19481 if (PyErr_Occurred()) SWIG_fail;
19482 }
19483 resultobj = SWIG_Py_Void();
19484 return resultobj;
19485 fail:
19486 return NULL;
19487 }
19488
19489
19490 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19491 PyObject *resultobj = 0;
19492 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19493 void *argp1 = 0 ;
19494 int res1 = 0 ;
19495 PyObject * obj0 = 0 ;
19496 char * kwnames[] = {
19497 (char *) "handler", NULL
19498 };
19499
19500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19502 if (!SWIG_IsOK(res1)) {
19503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19504 }
19505 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 wxImage::InsertHandler(arg1);
19509 wxPyEndAllowThreads(__tstate);
19510 if (PyErr_Occurred()) SWIG_fail;
19511 }
19512 resultobj = SWIG_Py_Void();
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19520 PyObject *resultobj = 0;
19521 wxString *arg1 = 0 ;
19522 bool result;
19523 bool temp1 = false ;
19524 PyObject * obj0 = 0 ;
19525 char * kwnames[] = {
19526 (char *) "name", NULL
19527 };
19528
19529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19530 {
19531 arg1 = wxString_in_helper(obj0);
19532 if (arg1 == NULL) SWIG_fail;
19533 temp1 = true;
19534 }
19535 {
19536 PyThreadState* __tstate = wxPyBeginAllowThreads();
19537 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19538 wxPyEndAllowThreads(__tstate);
19539 if (PyErr_Occurred()) SWIG_fail;
19540 }
19541 {
19542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19543 }
19544 {
19545 if (temp1)
19546 delete arg1;
19547 }
19548 return resultobj;
19549 fail:
19550 {
19551 if (temp1)
19552 delete arg1;
19553 }
19554 return NULL;
19555 }
19556
19557
19558 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19559 PyObject *resultobj = 0;
19560 PyObject *result = 0 ;
19561
19562 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 result = (PyObject *)wxImage_GetHandlers();
19566 wxPyEndAllowThreads(__tstate);
19567 if (PyErr_Occurred()) SWIG_fail;
19568 }
19569 resultobj = result;
19570 return resultobj;
19571 fail:
19572 return NULL;
19573 }
19574
19575
19576 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19577 PyObject *resultobj = 0;
19578 wxString result;
19579
19580 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = wxImage::GetImageExtWildcard();
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 {
19588 #if wxUSE_UNICODE
19589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19590 #else
19591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19592 #endif
19593 }
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19601 PyObject *resultobj = 0;
19602 wxImage *arg1 = (wxImage *) 0 ;
19603 int arg2 = (int) -1 ;
19604 wxBitmap result;
19605 void *argp1 = 0 ;
19606 int res1 = 0 ;
19607 int val2 ;
19608 int ecode2 = 0 ;
19609 PyObject * obj0 = 0 ;
19610 PyObject * obj1 = 0 ;
19611 char * kwnames[] = {
19612 (char *) "self",(char *) "depth", NULL
19613 };
19614
19615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19617 if (!SWIG_IsOK(res1)) {
19618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19619 }
19620 arg1 = reinterpret_cast< wxImage * >(argp1);
19621 if (obj1) {
19622 ecode2 = SWIG_AsVal_int(obj1, &val2);
19623 if (!SWIG_IsOK(ecode2)) {
19624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19625 }
19626 arg2 = static_cast< int >(val2);
19627 }
19628 {
19629 if (!wxPyCheckForApp()) SWIG_fail;
19630 PyThreadState* __tstate = wxPyBeginAllowThreads();
19631 result = wxImage_ConvertToBitmap(arg1,arg2);
19632 wxPyEndAllowThreads(__tstate);
19633 if (PyErr_Occurred()) SWIG_fail;
19634 }
19635 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19636 return resultobj;
19637 fail:
19638 return NULL;
19639 }
19640
19641
19642 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19643 PyObject *resultobj = 0;
19644 wxImage *arg1 = (wxImage *) 0 ;
19645 byte arg2 ;
19646 byte arg3 ;
19647 byte arg4 ;
19648 wxBitmap result;
19649 void *argp1 = 0 ;
19650 int res1 = 0 ;
19651 unsigned char val2 ;
19652 int ecode2 = 0 ;
19653 unsigned char val3 ;
19654 int ecode3 = 0 ;
19655 unsigned char val4 ;
19656 int ecode4 = 0 ;
19657 PyObject * obj0 = 0 ;
19658 PyObject * obj1 = 0 ;
19659 PyObject * obj2 = 0 ;
19660 PyObject * obj3 = 0 ;
19661 char * kwnames[] = {
19662 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19663 };
19664
19665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19667 if (!SWIG_IsOK(res1)) {
19668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19669 }
19670 arg1 = reinterpret_cast< wxImage * >(argp1);
19671 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19672 if (!SWIG_IsOK(ecode2)) {
19673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19674 }
19675 arg2 = static_cast< byte >(val2);
19676 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19677 if (!SWIG_IsOK(ecode3)) {
19678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19679 }
19680 arg3 = static_cast< byte >(val3);
19681 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19682 if (!SWIG_IsOK(ecode4)) {
19683 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19684 }
19685 arg4 = static_cast< byte >(val4);
19686 {
19687 if (!wxPyCheckForApp()) SWIG_fail;
19688 PyThreadState* __tstate = wxPyBeginAllowThreads();
19689 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj = 0;
19702 wxImage *arg1 = (wxImage *) 0 ;
19703 double arg2 ;
19704 void *argp1 = 0 ;
19705 int res1 = 0 ;
19706 double val2 ;
19707 int ecode2 = 0 ;
19708 PyObject * obj0 = 0 ;
19709 PyObject * obj1 = 0 ;
19710 char * kwnames[] = {
19711 (char *) "self",(char *) "angle", NULL
19712 };
19713
19714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19716 if (!SWIG_IsOK(res1)) {
19717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19718 }
19719 arg1 = reinterpret_cast< wxImage * >(argp1);
19720 ecode2 = SWIG_AsVal_double(obj1, &val2);
19721 if (!SWIG_IsOK(ecode2)) {
19722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19723 }
19724 arg2 = static_cast< double >(val2);
19725 {
19726 PyThreadState* __tstate = wxPyBeginAllowThreads();
19727 (arg1)->RotateHue(arg2);
19728 wxPyEndAllowThreads(__tstate);
19729 if (PyErr_Occurred()) SWIG_fail;
19730 }
19731 resultobj = SWIG_Py_Void();
19732 return resultobj;
19733 fail:
19734 return NULL;
19735 }
19736
19737
19738 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj = 0;
19740 wxImage_RGBValue arg1 ;
19741 wxImage_HSVValue result;
19742 void *argp1 ;
19743 int res1 = 0 ;
19744 PyObject * obj0 = 0 ;
19745 char * kwnames[] = {
19746 (char *) "rgb", NULL
19747 };
19748
19749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19750 {
19751 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19754 }
19755 if (!argp1) {
19756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19757 } else {
19758 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19759 arg1 = *temp;
19760 if (SWIG_IsNewObj(res1)) delete temp;
19761 }
19762 }
19763 {
19764 PyThreadState* __tstate = wxPyBeginAllowThreads();
19765 result = wxImage::RGBtoHSV(arg1);
19766 wxPyEndAllowThreads(__tstate);
19767 if (PyErr_Occurred()) SWIG_fail;
19768 }
19769 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19777 PyObject *resultobj = 0;
19778 wxImage_HSVValue arg1 ;
19779 wxImage_RGBValue result;
19780 void *argp1 ;
19781 int res1 = 0 ;
19782 PyObject * obj0 = 0 ;
19783 char * kwnames[] = {
19784 (char *) "hsv", NULL
19785 };
19786
19787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19788 {
19789 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19792 }
19793 if (!argp1) {
19794 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19795 } else {
19796 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19797 arg1 = *temp;
19798 if (SWIG_IsNewObj(res1)) delete temp;
19799 }
19800 }
19801 {
19802 PyThreadState* __tstate = wxPyBeginAllowThreads();
19803 result = wxImage::HSVtoRGB(arg1);
19804 wxPyEndAllowThreads(__tstate);
19805 if (PyErr_Occurred()) SWIG_fail;
19806 }
19807 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19808 return resultobj;
19809 fail:
19810 return NULL;
19811 }
19812
19813
19814 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19815 PyObject *obj;
19816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19817 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19818 return SWIG_Py_Void();
19819 }
19820
19821 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19822 return SWIG_Python_InitShadowInstance(args);
19823 }
19824
19825 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19826 PyObject *resultobj = 0;
19827 int arg1 ;
19828 int arg2 ;
19829 buffer arg3 ;
19830 int arg4 ;
19831 buffer arg5 = (buffer) NULL ;
19832 int arg6 = (int) 0 ;
19833 wxImage *result = 0 ;
19834 int val1 ;
19835 int ecode1 = 0 ;
19836 int val2 ;
19837 int ecode2 = 0 ;
19838 Py_ssize_t temp3 ;
19839 Py_ssize_t temp5 ;
19840 PyObject * obj0 = 0 ;
19841 PyObject * obj1 = 0 ;
19842 PyObject * obj2 = 0 ;
19843 PyObject * obj3 = 0 ;
19844 char * kwnames[] = {
19845 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19846 };
19847
19848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19849 ecode1 = SWIG_AsVal_int(obj0, &val1);
19850 if (!SWIG_IsOK(ecode1)) {
19851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19852 }
19853 arg1 = static_cast< int >(val1);
19854 ecode2 = SWIG_AsVal_int(obj1, &val2);
19855 if (!SWIG_IsOK(ecode2)) {
19856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19857 }
19858 arg2 = static_cast< int >(val2);
19859 {
19860 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19861 arg4 = (int)temp3;
19862 }
19863 if (obj3) {
19864 {
19865 if (obj3 != Py_None) {
19866 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19867 arg6 = (int)temp5;
19868 }
19869 }
19870 }
19871 {
19872 PyThreadState* __tstate = wxPyBeginAllowThreads();
19873 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19874 wxPyEndAllowThreads(__tstate);
19875 if (PyErr_Occurred()) SWIG_fail;
19876 }
19877 {
19878 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19879 }
19880 return resultobj;
19881 fail:
19882 return NULL;
19883 }
19884
19885
19886 SWIGINTERN int NullImage_set(PyObject *) {
19887 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19888 return 1;
19889 }
19890
19891
19892 SWIGINTERN PyObject *NullImage_get(void) {
19893 PyObject *pyobj = 0;
19894
19895 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19896 return pyobj;
19897 }
19898
19899
19900 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19901 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19902 return 1;
19903 }
19904
19905
19906 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19907 PyObject *pyobj = 0;
19908
19909 {
19910 #if wxUSE_UNICODE
19911 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19912 #else
19913 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19914 #endif
19915 }
19916 return pyobj;
19917 }
19918
19919
19920 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19921 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19922 return 1;
19923 }
19924
19925
19926 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19927 PyObject *pyobj = 0;
19928
19929 {
19930 #if wxUSE_UNICODE
19931 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19932 #else
19933 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19934 #endif
19935 }
19936 return pyobj;
19937 }
19938
19939
19940 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19941 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19942 return 1;
19943 }
19944
19945
19946 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19947 PyObject *pyobj = 0;
19948
19949 {
19950 #if wxUSE_UNICODE
19951 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19952 #else
19953 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19954 #endif
19955 }
19956 return pyobj;
19957 }
19958
19959
19960 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19961 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19962 return 1;
19963 }
19964
19965
19966 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19967 PyObject *pyobj = 0;
19968
19969 {
19970 #if wxUSE_UNICODE
19971 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19972 #else
19973 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19974 #endif
19975 }
19976 return pyobj;
19977 }
19978
19979
19980 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19981 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19982 return 1;
19983 }
19984
19985
19986 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19987 PyObject *pyobj = 0;
19988
19989 {
19990 #if wxUSE_UNICODE
19991 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19992 #else
19993 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19994 #endif
19995 }
19996 return pyobj;
19997 }
19998
19999
20000 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20001 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20002 return 1;
20003 }
20004
20005
20006 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20007 PyObject *pyobj = 0;
20008
20009 {
20010 #if wxUSE_UNICODE
20011 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20012 #else
20013 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20014 #endif
20015 }
20016 return pyobj;
20017 }
20018
20019
20020 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20021 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20022 return 1;
20023 }
20024
20025
20026 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20027 PyObject *pyobj = 0;
20028
20029 {
20030 #if wxUSE_UNICODE
20031 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20032 #else
20033 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20034 #endif
20035 }
20036 return pyobj;
20037 }
20038
20039
20040 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20041 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20042 return 1;
20043 }
20044
20045
20046 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20047 PyObject *pyobj = 0;
20048
20049 {
20050 #if wxUSE_UNICODE
20051 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20052 #else
20053 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20054 #endif
20055 }
20056 return pyobj;
20057 }
20058
20059
20060 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20061 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20062 return 1;
20063 }
20064
20065
20066 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20067 PyObject *pyobj = 0;
20068
20069 {
20070 #if wxUSE_UNICODE
20071 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20072 #else
20073 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20074 #endif
20075 }
20076 return pyobj;
20077 }
20078
20079
20080 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20081 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20082 return 1;
20083 }
20084
20085
20086 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20087 PyObject *pyobj = 0;
20088
20089 {
20090 #if wxUSE_UNICODE
20091 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20092 #else
20093 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20094 #endif
20095 }
20096 return pyobj;
20097 }
20098
20099
20100 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20101 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20102 return 1;
20103 }
20104
20105
20106 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20107 PyObject *pyobj = 0;
20108
20109 {
20110 #if wxUSE_UNICODE
20111 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20112 #else
20113 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20114 #endif
20115 }
20116 return pyobj;
20117 }
20118
20119
20120 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20121 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20122 return 1;
20123 }
20124
20125
20126 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20127 PyObject *pyobj = 0;
20128
20129 {
20130 #if wxUSE_UNICODE
20131 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20132 #else
20133 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20134 #endif
20135 }
20136 return pyobj;
20137 }
20138
20139
20140 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20141 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20142 return 1;
20143 }
20144
20145
20146 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20147 PyObject *pyobj = 0;
20148
20149 {
20150 #if wxUSE_UNICODE
20151 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20152 #else
20153 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20154 #endif
20155 }
20156 return pyobj;
20157 }
20158
20159
20160 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20161 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20162 return 1;
20163 }
20164
20165
20166 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20167 PyObject *pyobj = 0;
20168
20169 {
20170 #if wxUSE_UNICODE
20171 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20172 #else
20173 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20174 #endif
20175 }
20176 return pyobj;
20177 }
20178
20179
20180 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20181 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20182 return 1;
20183 }
20184
20185
20186 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20187 PyObject *pyobj = 0;
20188
20189 {
20190 #if wxUSE_UNICODE
20191 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20192 #else
20193 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20194 #endif
20195 }
20196 return pyobj;
20197 }
20198
20199
20200 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201 PyObject *resultobj = 0;
20202 wxBMPHandler *result = 0 ;
20203
20204 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20205 {
20206 PyThreadState* __tstate = wxPyBeginAllowThreads();
20207 result = (wxBMPHandler *)new wxBMPHandler();
20208 wxPyEndAllowThreads(__tstate);
20209 if (PyErr_Occurred()) SWIG_fail;
20210 }
20211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20219 PyObject *obj;
20220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20221 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20222 return SWIG_Py_Void();
20223 }
20224
20225 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20226 return SWIG_Python_InitShadowInstance(args);
20227 }
20228
20229 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *resultobj = 0;
20231 wxICOHandler *result = 0 ;
20232
20233 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (wxICOHandler *)new wxICOHandler();
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20248 PyObject *obj;
20249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20250 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20251 return SWIG_Py_Void();
20252 }
20253
20254 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 return SWIG_Python_InitShadowInstance(args);
20256 }
20257
20258 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20259 PyObject *resultobj = 0;
20260 wxCURHandler *result = 0 ;
20261
20262 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (wxCURHandler *)new wxCURHandler();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *obj;
20278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20279 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20280 return SWIG_Py_Void();
20281 }
20282
20283 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20284 return SWIG_Python_InitShadowInstance(args);
20285 }
20286
20287 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *resultobj = 0;
20289 wxANIHandler *result = 0 ;
20290
20291 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (wxANIHandler *)new wxANIHandler();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20306 PyObject *obj;
20307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20308 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20309 return SWIG_Py_Void();
20310 }
20311
20312 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 return SWIG_Python_InitShadowInstance(args);
20314 }
20315
20316 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *resultobj = 0;
20318 wxPNGHandler *result = 0 ;
20319
20320 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (wxPNGHandler *)new wxPNGHandler();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20335 PyObject *obj;
20336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20337 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20338 return SWIG_Py_Void();
20339 }
20340
20341 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20342 return SWIG_Python_InitShadowInstance(args);
20343 }
20344
20345 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20346 PyObject *resultobj = 0;
20347 wxGIFHandler *result = 0 ;
20348
20349 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (wxGIFHandler *)new wxGIFHandler();
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *obj;
20365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20367 return SWIG_Py_Void();
20368 }
20369
20370 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 return SWIG_Python_InitShadowInstance(args);
20372 }
20373
20374 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxPCXHandler *result = 0 ;
20377
20378 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (wxPCXHandler *)new wxPCXHandler();
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *obj;
20394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20395 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20396 return SWIG_Py_Void();
20397 }
20398
20399 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 return SWIG_Python_InitShadowInstance(args);
20401 }
20402
20403 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404 PyObject *resultobj = 0;
20405 wxJPEGHandler *result = 0 ;
20406
20407 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (wxJPEGHandler *)new wxJPEGHandler();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20422 PyObject *obj;
20423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20424 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20425 return SWIG_Py_Void();
20426 }
20427
20428 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20429 return SWIG_Python_InitShadowInstance(args);
20430 }
20431
20432 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxPNMHandler *result = 0 ;
20435
20436 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (wxPNMHandler *)new wxPNMHandler();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20451 PyObject *obj;
20452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20453 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20454 return SWIG_Py_Void();
20455 }
20456
20457 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 return SWIG_Python_InitShadowInstance(args);
20459 }
20460
20461 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20462 PyObject *resultobj = 0;
20463 wxXPMHandler *result = 0 ;
20464
20465 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20466 {
20467 PyThreadState* __tstate = wxPyBeginAllowThreads();
20468 result = (wxXPMHandler *)new wxXPMHandler();
20469 wxPyEndAllowThreads(__tstate);
20470 if (PyErr_Occurred()) SWIG_fail;
20471 }
20472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20480 PyObject *obj;
20481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20482 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20483 return SWIG_Py_Void();
20484 }
20485
20486 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20487 return SWIG_Python_InitShadowInstance(args);
20488 }
20489
20490 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20491 PyObject *resultobj = 0;
20492 wxTIFFHandler *result = 0 ;
20493
20494 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20495 {
20496 PyThreadState* __tstate = wxPyBeginAllowThreads();
20497 result = (wxTIFFHandler *)new wxTIFFHandler();
20498 wxPyEndAllowThreads(__tstate);
20499 if (PyErr_Occurred()) SWIG_fail;
20500 }
20501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20502 return resultobj;
20503 fail:
20504 return NULL;
20505 }
20506
20507
20508 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20509 PyObject *obj;
20510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20511 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20512 return SWIG_Py_Void();
20513 }
20514
20515 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20516 return SWIG_Python_InitShadowInstance(args);
20517 }
20518
20519 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20520 PyObject *resultobj = 0;
20521 wxTGAHandler *result = 0 ;
20522
20523 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (wxTGAHandler *)new wxTGAHandler();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20531 return resultobj;
20532 fail:
20533 return NULL;
20534 }
20535
20536
20537 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *obj;
20539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20540 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20541 return SWIG_Py_Void();
20542 }
20543
20544 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20545 return SWIG_Python_InitShadowInstance(args);
20546 }
20547
20548 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20549 PyObject *resultobj = 0;
20550 wxImage *arg1 = 0 ;
20551 wxImage *arg2 = 0 ;
20552 int arg3 = (int) 236 ;
20553 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20554 bool result;
20555 void *argp1 = 0 ;
20556 int res1 = 0 ;
20557 void *argp2 = 0 ;
20558 int res2 = 0 ;
20559 int val3 ;
20560 int ecode3 = 0 ;
20561 int val4 ;
20562 int ecode4 = 0 ;
20563 PyObject * obj0 = 0 ;
20564 PyObject * obj1 = 0 ;
20565 PyObject * obj2 = 0 ;
20566 PyObject * obj3 = 0 ;
20567 char * kwnames[] = {
20568 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20569 };
20570
20571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20572 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20573 if (!SWIG_IsOK(res1)) {
20574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20575 }
20576 if (!argp1) {
20577 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20578 }
20579 arg1 = reinterpret_cast< wxImage * >(argp1);
20580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20581 if (!SWIG_IsOK(res2)) {
20582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20583 }
20584 if (!argp2) {
20585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20586 }
20587 arg2 = reinterpret_cast< wxImage * >(argp2);
20588 if (obj2) {
20589 ecode3 = SWIG_AsVal_int(obj2, &val3);
20590 if (!SWIG_IsOK(ecode3)) {
20591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20592 }
20593 arg3 = static_cast< int >(val3);
20594 }
20595 if (obj3) {
20596 ecode4 = SWIG_AsVal_int(obj3, &val4);
20597 if (!SWIG_IsOK(ecode4)) {
20598 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20599 }
20600 arg4 = static_cast< int >(val4);
20601 }
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20605 wxPyEndAllowThreads(__tstate);
20606 if (PyErr_Occurred()) SWIG_fail;
20607 }
20608 {
20609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20610 }
20611 return resultobj;
20612 fail:
20613 return NULL;
20614 }
20615
20616
20617 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20618 PyObject *obj;
20619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20620 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20621 return SWIG_Py_Void();
20622 }
20623
20624 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20625 PyObject *resultobj = 0;
20626 wxEvtHandler *result = 0 ;
20627
20628 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20629 {
20630 PyThreadState* __tstate = wxPyBeginAllowThreads();
20631 result = (wxEvtHandler *)new wxEvtHandler();
20632 wxPyEndAllowThreads(__tstate);
20633 if (PyErr_Occurred()) SWIG_fail;
20634 }
20635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20636 return resultobj;
20637 fail:
20638 return NULL;
20639 }
20640
20641
20642 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20643 PyObject *resultobj = 0;
20644 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20645 wxEvtHandler *result = 0 ;
20646 void *argp1 = 0 ;
20647 int res1 = 0 ;
20648 PyObject *swig_obj[1] ;
20649
20650 if (!args) SWIG_fail;
20651 swig_obj[0] = args;
20652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20653 if (!SWIG_IsOK(res1)) {
20654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20655 }
20656 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20657 {
20658 PyThreadState* __tstate = wxPyBeginAllowThreads();
20659 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20660 wxPyEndAllowThreads(__tstate);
20661 if (PyErr_Occurred()) SWIG_fail;
20662 }
20663 {
20664 resultobj = wxPyMake_wxObject(result, 0);
20665 }
20666 return resultobj;
20667 fail:
20668 return NULL;
20669 }
20670
20671
20672 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20673 PyObject *resultobj = 0;
20674 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20675 wxEvtHandler *result = 0 ;
20676 void *argp1 = 0 ;
20677 int res1 = 0 ;
20678 PyObject *swig_obj[1] ;
20679
20680 if (!args) SWIG_fail;
20681 swig_obj[0] = args;
20682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20683 if (!SWIG_IsOK(res1)) {
20684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20685 }
20686 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20687 {
20688 PyThreadState* __tstate = wxPyBeginAllowThreads();
20689 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20690 wxPyEndAllowThreads(__tstate);
20691 if (PyErr_Occurred()) SWIG_fail;
20692 }
20693 {
20694 resultobj = wxPyMake_wxObject(result, 0);
20695 }
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj = 0;
20704 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20705 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20706 void *argp1 = 0 ;
20707 int res1 = 0 ;
20708 void *argp2 = 0 ;
20709 int res2 = 0 ;
20710 PyObject * obj0 = 0 ;
20711 PyObject * obj1 = 0 ;
20712 char * kwnames[] = {
20713 (char *) "self",(char *) "handler", NULL
20714 };
20715
20716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20718 if (!SWIG_IsOK(res1)) {
20719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20720 }
20721 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20722 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20723 if (!SWIG_IsOK(res2)) {
20724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20725 }
20726 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 (arg1)->SetNextHandler(arg2);
20730 wxPyEndAllowThreads(__tstate);
20731 if (PyErr_Occurred()) SWIG_fail;
20732 }
20733 resultobj = SWIG_Py_Void();
20734 return resultobj;
20735 fail:
20736 return NULL;
20737 }
20738
20739
20740 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20741 PyObject *resultobj = 0;
20742 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20743 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20744 void *argp1 = 0 ;
20745 int res1 = 0 ;
20746 void *argp2 = 0 ;
20747 int res2 = 0 ;
20748 PyObject * obj0 = 0 ;
20749 PyObject * obj1 = 0 ;
20750 char * kwnames[] = {
20751 (char *) "self",(char *) "handler", NULL
20752 };
20753
20754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20758 }
20759 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20761 if (!SWIG_IsOK(res2)) {
20762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20763 }
20764 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20765 {
20766 PyThreadState* __tstate = wxPyBeginAllowThreads();
20767 (arg1)->SetPreviousHandler(arg2);
20768 wxPyEndAllowThreads(__tstate);
20769 if (PyErr_Occurred()) SWIG_fail;
20770 }
20771 resultobj = SWIG_Py_Void();
20772 return resultobj;
20773 fail:
20774 return NULL;
20775 }
20776
20777
20778 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20779 PyObject *resultobj = 0;
20780 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20781 bool result;
20782 void *argp1 = 0 ;
20783 int res1 = 0 ;
20784 PyObject *swig_obj[1] ;
20785
20786 if (!args) SWIG_fail;
20787 swig_obj[0] = args;
20788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20789 if (!SWIG_IsOK(res1)) {
20790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20791 }
20792 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = (bool)(arg1)->GetEvtHandlerEnabled();
20796 wxPyEndAllowThreads(__tstate);
20797 if (PyErr_Occurred()) SWIG_fail;
20798 }
20799 {
20800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20801 }
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20809 PyObject *resultobj = 0;
20810 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20811 bool arg2 ;
20812 void *argp1 = 0 ;
20813 int res1 = 0 ;
20814 bool val2 ;
20815 int ecode2 = 0 ;
20816 PyObject * obj0 = 0 ;
20817 PyObject * obj1 = 0 ;
20818 char * kwnames[] = {
20819 (char *) "self",(char *) "enabled", NULL
20820 };
20821
20822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20824 if (!SWIG_IsOK(res1)) {
20825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20826 }
20827 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20828 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20829 if (!SWIG_IsOK(ecode2)) {
20830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20831 }
20832 arg2 = static_cast< bool >(val2);
20833 {
20834 PyThreadState* __tstate = wxPyBeginAllowThreads();
20835 (arg1)->SetEvtHandlerEnabled(arg2);
20836 wxPyEndAllowThreads(__tstate);
20837 if (PyErr_Occurred()) SWIG_fail;
20838 }
20839 resultobj = SWIG_Py_Void();
20840 return resultobj;
20841 fail:
20842 return NULL;
20843 }
20844
20845
20846 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20847 PyObject *resultobj = 0;
20848 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20849 wxEvent *arg2 = 0 ;
20850 bool result;
20851 void *argp1 = 0 ;
20852 int res1 = 0 ;
20853 void *argp2 = 0 ;
20854 int res2 = 0 ;
20855 PyObject * obj0 = 0 ;
20856 PyObject * obj1 = 0 ;
20857 char * kwnames[] = {
20858 (char *) "self",(char *) "event", NULL
20859 };
20860
20861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20863 if (!SWIG_IsOK(res1)) {
20864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20865 }
20866 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20867 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20868 if (!SWIG_IsOK(res2)) {
20869 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20870 }
20871 if (!argp2) {
20872 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20873 }
20874 arg2 = reinterpret_cast< wxEvent * >(argp2);
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (bool)(arg1)->ProcessEvent(*arg2);
20878 wxPyEndAllowThreads(__tstate);
20879 if (PyErr_Occurred()) SWIG_fail;
20880 }
20881 {
20882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20883 }
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20891 PyObject *resultobj = 0;
20892 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20893 wxEvent *arg2 = 0 ;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 void *argp2 = 0 ;
20897 int res2 = 0 ;
20898 PyObject * obj0 = 0 ;
20899 PyObject * obj1 = 0 ;
20900 char * kwnames[] = {
20901 (char *) "self",(char *) "event", NULL
20902 };
20903
20904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20906 if (!SWIG_IsOK(res1)) {
20907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20908 }
20909 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20910 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20911 if (!SWIG_IsOK(res2)) {
20912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20913 }
20914 if (!argp2) {
20915 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20916 }
20917 arg2 = reinterpret_cast< wxEvent * >(argp2);
20918 {
20919 PyThreadState* __tstate = wxPyBeginAllowThreads();
20920 (arg1)->AddPendingEvent(*arg2);
20921 wxPyEndAllowThreads(__tstate);
20922 if (PyErr_Occurred()) SWIG_fail;
20923 }
20924 resultobj = SWIG_Py_Void();
20925 return resultobj;
20926 fail:
20927 return NULL;
20928 }
20929
20930
20931 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20932 PyObject *resultobj = 0;
20933 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20934 void *argp1 = 0 ;
20935 int res1 = 0 ;
20936 PyObject *swig_obj[1] ;
20937
20938 if (!args) SWIG_fail;
20939 swig_obj[0] = args;
20940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20941 if (!SWIG_IsOK(res1)) {
20942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20943 }
20944 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20945 {
20946 PyThreadState* __tstate = wxPyBeginAllowThreads();
20947 (arg1)->ProcessPendingEvents();
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_Py_Void();
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20959 PyObject *resultobj = 0;
20960 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20961 int arg2 ;
20962 int arg3 ;
20963 int arg4 ;
20964 PyObject *arg5 = (PyObject *) 0 ;
20965 void *argp1 = 0 ;
20966 int res1 = 0 ;
20967 int val2 ;
20968 int ecode2 = 0 ;
20969 int val3 ;
20970 int ecode3 = 0 ;
20971 int val4 ;
20972 int ecode4 = 0 ;
20973 PyObject * obj0 = 0 ;
20974 PyObject * obj1 = 0 ;
20975 PyObject * obj2 = 0 ;
20976 PyObject * obj3 = 0 ;
20977 PyObject * obj4 = 0 ;
20978 char * kwnames[] = {
20979 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20980 };
20981
20982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20984 if (!SWIG_IsOK(res1)) {
20985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20986 }
20987 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20988 ecode2 = SWIG_AsVal_int(obj1, &val2);
20989 if (!SWIG_IsOK(ecode2)) {
20990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20991 }
20992 arg2 = static_cast< int >(val2);
20993 ecode3 = SWIG_AsVal_int(obj2, &val3);
20994 if (!SWIG_IsOK(ecode3)) {
20995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20996 }
20997 arg3 = static_cast< int >(val3);
20998 ecode4 = SWIG_AsVal_int(obj3, &val4);
20999 if (!SWIG_IsOK(ecode4)) {
21000 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21001 }
21002 arg4 = static_cast< int >(val4);
21003 arg5 = obj4;
21004 {
21005 PyThreadState* __tstate = wxPyBeginAllowThreads();
21006 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21007 wxPyEndAllowThreads(__tstate);
21008 if (PyErr_Occurred()) SWIG_fail;
21009 }
21010 resultobj = SWIG_Py_Void();
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21018 PyObject *resultobj = 0;
21019 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21020 int arg2 ;
21021 int arg3 = (int) -1 ;
21022 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21023 bool result;
21024 void *argp1 = 0 ;
21025 int res1 = 0 ;
21026 int val2 ;
21027 int ecode2 = 0 ;
21028 int val3 ;
21029 int ecode3 = 0 ;
21030 int val4 ;
21031 int ecode4 = 0 ;
21032 PyObject * obj0 = 0 ;
21033 PyObject * obj1 = 0 ;
21034 PyObject * obj2 = 0 ;
21035 PyObject * obj3 = 0 ;
21036 char * kwnames[] = {
21037 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21038 };
21039
21040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21042 if (!SWIG_IsOK(res1)) {
21043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21044 }
21045 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21046 ecode2 = SWIG_AsVal_int(obj1, &val2);
21047 if (!SWIG_IsOK(ecode2)) {
21048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21049 }
21050 arg2 = static_cast< int >(val2);
21051 if (obj2) {
21052 ecode3 = SWIG_AsVal_int(obj2, &val3);
21053 if (!SWIG_IsOK(ecode3)) {
21054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21055 }
21056 arg3 = static_cast< int >(val3);
21057 }
21058 if (obj3) {
21059 ecode4 = SWIG_AsVal_int(obj3, &val4);
21060 if (!SWIG_IsOK(ecode4)) {
21061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21062 }
21063 arg4 = static_cast< wxEventType >(val4);
21064 }
21065 {
21066 PyThreadState* __tstate = wxPyBeginAllowThreads();
21067 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 {
21072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21073 }
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21081 PyObject *resultobj = 0;
21082 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21083 PyObject *arg2 = (PyObject *) 0 ;
21084 bool arg3 = (bool) true ;
21085 void *argp1 = 0 ;
21086 int res1 = 0 ;
21087 bool val3 ;
21088 int ecode3 = 0 ;
21089 PyObject * obj0 = 0 ;
21090 PyObject * obj1 = 0 ;
21091 PyObject * obj2 = 0 ;
21092 char * kwnames[] = {
21093 (char *) "self",(char *) "_self",(char *) "incref", NULL
21094 };
21095
21096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21098 if (!SWIG_IsOK(res1)) {
21099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21100 }
21101 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21102 arg2 = obj1;
21103 if (obj2) {
21104 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21105 if (!SWIG_IsOK(ecode3)) {
21106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21107 }
21108 arg3 = static_cast< bool >(val3);
21109 }
21110 {
21111 PyThreadState* __tstate = wxPyBeginAllowThreads();
21112 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21113 wxPyEndAllowThreads(__tstate);
21114 if (PyErr_Occurred()) SWIG_fail;
21115 }
21116 resultobj = SWIG_Py_Void();
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21124 PyObject *obj;
21125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21126 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21127 return SWIG_Py_Void();
21128 }
21129
21130 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 return SWIG_Python_InitShadowInstance(args);
21132 }
21133
21134 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21135 PyObject *resultobj = 0;
21136 wxEventType result;
21137
21138 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 result = (wxEventType)wxNewEventType();
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 resultobj = SWIG_From_int(static_cast< int >(result));
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxEvent *arg1 = (wxEvent *) 0 ;
21155 void *argp1 = 0 ;
21156 int res1 = 0 ;
21157 PyObject *swig_obj[1] ;
21158
21159 if (!args) SWIG_fail;
21160 swig_obj[0] = args;
21161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21162 if (!SWIG_IsOK(res1)) {
21163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21164 }
21165 arg1 = reinterpret_cast< wxEvent * >(argp1);
21166 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 delete arg1;
21169
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 resultobj = SWIG_Py_Void();
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj = 0;
21182 wxEvent *arg1 = (wxEvent *) 0 ;
21183 wxEventType arg2 ;
21184 void *argp1 = 0 ;
21185 int res1 = 0 ;
21186 int val2 ;
21187 int ecode2 = 0 ;
21188 PyObject * obj0 = 0 ;
21189 PyObject * obj1 = 0 ;
21190 char * kwnames[] = {
21191 (char *) "self",(char *) "typ", NULL
21192 };
21193
21194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21196 if (!SWIG_IsOK(res1)) {
21197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21198 }
21199 arg1 = reinterpret_cast< wxEvent * >(argp1);
21200 ecode2 = SWIG_AsVal_int(obj1, &val2);
21201 if (!SWIG_IsOK(ecode2)) {
21202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21203 }
21204 arg2 = static_cast< wxEventType >(val2);
21205 {
21206 PyThreadState* __tstate = wxPyBeginAllowThreads();
21207 (arg1)->SetEventType(arg2);
21208 wxPyEndAllowThreads(__tstate);
21209 if (PyErr_Occurred()) SWIG_fail;
21210 }
21211 resultobj = SWIG_Py_Void();
21212 return resultobj;
21213 fail:
21214 return NULL;
21215 }
21216
21217
21218 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21219 PyObject *resultobj = 0;
21220 wxEvent *arg1 = (wxEvent *) 0 ;
21221 wxEventType result;
21222 void *argp1 = 0 ;
21223 int res1 = 0 ;
21224 PyObject *swig_obj[1] ;
21225
21226 if (!args) SWIG_fail;
21227 swig_obj[0] = args;
21228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21229 if (!SWIG_IsOK(res1)) {
21230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21231 }
21232 arg1 = reinterpret_cast< wxEvent * >(argp1);
21233 {
21234 PyThreadState* __tstate = wxPyBeginAllowThreads();
21235 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 resultobj = SWIG_From_int(static_cast< int >(result));
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21247 PyObject *resultobj = 0;
21248 wxEvent *arg1 = (wxEvent *) 0 ;
21249 wxObject *result = 0 ;
21250 void *argp1 = 0 ;
21251 int res1 = 0 ;
21252 PyObject *swig_obj[1] ;
21253
21254 if (!args) SWIG_fail;
21255 swig_obj[0] = args;
21256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21257 if (!SWIG_IsOK(res1)) {
21258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21259 }
21260 arg1 = reinterpret_cast< wxEvent * >(argp1);
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21264 wxPyEndAllowThreads(__tstate);
21265 if (PyErr_Occurred()) SWIG_fail;
21266 }
21267 {
21268 resultobj = wxPyMake_wxObject(result, (bool)0);
21269 }
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj = 0;
21278 wxEvent *arg1 = (wxEvent *) 0 ;
21279 wxObject *arg2 = (wxObject *) 0 ;
21280 void *argp1 = 0 ;
21281 int res1 = 0 ;
21282 void *argp2 = 0 ;
21283 int res2 = 0 ;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 char * kwnames[] = {
21287 (char *) "self",(char *) "obj", NULL
21288 };
21289
21290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21294 }
21295 arg1 = reinterpret_cast< wxEvent * >(argp1);
21296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21297 if (!SWIG_IsOK(res2)) {
21298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21299 }
21300 arg2 = reinterpret_cast< wxObject * >(argp2);
21301 {
21302 PyThreadState* __tstate = wxPyBeginAllowThreads();
21303 (arg1)->SetEventObject(arg2);
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 resultobj = SWIG_Py_Void();
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxEvent *arg1 = (wxEvent *) 0 ;
21317 long result;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 PyObject *swig_obj[1] ;
21321
21322 if (!args) SWIG_fail;
21323 swig_obj[0] = args;
21324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21327 }
21328 arg1 = reinterpret_cast< wxEvent * >(argp1);
21329 {
21330 PyThreadState* __tstate = wxPyBeginAllowThreads();
21331 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21332 wxPyEndAllowThreads(__tstate);
21333 if (PyErr_Occurred()) SWIG_fail;
21334 }
21335 resultobj = SWIG_From_long(static_cast< long >(result));
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21343 PyObject *resultobj = 0;
21344 wxEvent *arg1 = (wxEvent *) 0 ;
21345 long arg2 = (long) 0 ;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 long val2 ;
21349 int ecode2 = 0 ;
21350 PyObject * obj0 = 0 ;
21351 PyObject * obj1 = 0 ;
21352 char * kwnames[] = {
21353 (char *) "self",(char *) "ts", NULL
21354 };
21355
21356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21358 if (!SWIG_IsOK(res1)) {
21359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21360 }
21361 arg1 = reinterpret_cast< wxEvent * >(argp1);
21362 if (obj1) {
21363 ecode2 = SWIG_AsVal_long(obj1, &val2);
21364 if (!SWIG_IsOK(ecode2)) {
21365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21366 }
21367 arg2 = static_cast< long >(val2);
21368 }
21369 {
21370 PyThreadState* __tstate = wxPyBeginAllowThreads();
21371 (arg1)->SetTimestamp(arg2);
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_Py_Void();
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21383 PyObject *resultobj = 0;
21384 wxEvent *arg1 = (wxEvent *) 0 ;
21385 int result;
21386 void *argp1 = 0 ;
21387 int res1 = 0 ;
21388 PyObject *swig_obj[1] ;
21389
21390 if (!args) SWIG_fail;
21391 swig_obj[0] = args;
21392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21393 if (!SWIG_IsOK(res1)) {
21394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21395 }
21396 arg1 = reinterpret_cast< wxEvent * >(argp1);
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 result = (int)((wxEvent const *)arg1)->GetId();
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 resultobj = SWIG_From_int(static_cast< int >(result));
21404 return resultobj;
21405 fail:
21406 return NULL;
21407 }
21408
21409
21410 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21411 PyObject *resultobj = 0;
21412 wxEvent *arg1 = (wxEvent *) 0 ;
21413 int arg2 ;
21414 void *argp1 = 0 ;
21415 int res1 = 0 ;
21416 int val2 ;
21417 int ecode2 = 0 ;
21418 PyObject * obj0 = 0 ;
21419 PyObject * obj1 = 0 ;
21420 char * kwnames[] = {
21421 (char *) "self",(char *) "Id", NULL
21422 };
21423
21424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21426 if (!SWIG_IsOK(res1)) {
21427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21428 }
21429 arg1 = reinterpret_cast< wxEvent * >(argp1);
21430 ecode2 = SWIG_AsVal_int(obj1, &val2);
21431 if (!SWIG_IsOK(ecode2)) {
21432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21433 }
21434 arg2 = static_cast< int >(val2);
21435 {
21436 PyThreadState* __tstate = wxPyBeginAllowThreads();
21437 (arg1)->SetId(arg2);
21438 wxPyEndAllowThreads(__tstate);
21439 if (PyErr_Occurred()) SWIG_fail;
21440 }
21441 resultobj = SWIG_Py_Void();
21442 return resultobj;
21443 fail:
21444 return NULL;
21445 }
21446
21447
21448 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21449 PyObject *resultobj = 0;
21450 wxEvent *arg1 = (wxEvent *) 0 ;
21451 bool result;
21452 void *argp1 = 0 ;
21453 int res1 = 0 ;
21454 PyObject *swig_obj[1] ;
21455
21456 if (!args) SWIG_fail;
21457 swig_obj[0] = args;
21458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21459 if (!SWIG_IsOK(res1)) {
21460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21461 }
21462 arg1 = reinterpret_cast< wxEvent * >(argp1);
21463 {
21464 PyThreadState* __tstate = wxPyBeginAllowThreads();
21465 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 {
21470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21471 }
21472 return resultobj;
21473 fail:
21474 return NULL;
21475 }
21476
21477
21478 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21479 PyObject *resultobj = 0;
21480 wxEvent *arg1 = (wxEvent *) 0 ;
21481 bool arg2 = (bool) true ;
21482 void *argp1 = 0 ;
21483 int res1 = 0 ;
21484 bool val2 ;
21485 int ecode2 = 0 ;
21486 PyObject * obj0 = 0 ;
21487 PyObject * obj1 = 0 ;
21488 char * kwnames[] = {
21489 (char *) "self",(char *) "skip", NULL
21490 };
21491
21492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21494 if (!SWIG_IsOK(res1)) {
21495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21496 }
21497 arg1 = reinterpret_cast< wxEvent * >(argp1);
21498 if (obj1) {
21499 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21500 if (!SWIG_IsOK(ecode2)) {
21501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21502 }
21503 arg2 = static_cast< bool >(val2);
21504 }
21505 {
21506 PyThreadState* __tstate = wxPyBeginAllowThreads();
21507 (arg1)->Skip(arg2);
21508 wxPyEndAllowThreads(__tstate);
21509 if (PyErr_Occurred()) SWIG_fail;
21510 }
21511 resultobj = SWIG_Py_Void();
21512 return resultobj;
21513 fail:
21514 return NULL;
21515 }
21516
21517
21518 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21519 PyObject *resultobj = 0;
21520 wxEvent *arg1 = (wxEvent *) 0 ;
21521 bool result;
21522 void *argp1 = 0 ;
21523 int res1 = 0 ;
21524 PyObject *swig_obj[1] ;
21525
21526 if (!args) SWIG_fail;
21527 swig_obj[0] = args;
21528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21529 if (!SWIG_IsOK(res1)) {
21530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21531 }
21532 arg1 = reinterpret_cast< wxEvent * >(argp1);
21533 {
21534 PyThreadState* __tstate = wxPyBeginAllowThreads();
21535 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21536 wxPyEndAllowThreads(__tstate);
21537 if (PyErr_Occurred()) SWIG_fail;
21538 }
21539 {
21540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21541 }
21542 return resultobj;
21543 fail:
21544 return NULL;
21545 }
21546
21547
21548 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21549 PyObject *resultobj = 0;
21550 wxEvent *arg1 = (wxEvent *) 0 ;
21551 bool result;
21552 void *argp1 = 0 ;
21553 int res1 = 0 ;
21554 PyObject *swig_obj[1] ;
21555
21556 if (!args) SWIG_fail;
21557 swig_obj[0] = args;
21558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21559 if (!SWIG_IsOK(res1)) {
21560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21561 }
21562 arg1 = reinterpret_cast< wxEvent * >(argp1);
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21566 wxPyEndAllowThreads(__tstate);
21567 if (PyErr_Occurred()) SWIG_fail;
21568 }
21569 {
21570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21571 }
21572 return resultobj;
21573 fail:
21574 return NULL;
21575 }
21576
21577
21578 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21579 PyObject *resultobj = 0;
21580 wxEvent *arg1 = (wxEvent *) 0 ;
21581 int result;
21582 void *argp1 = 0 ;
21583 int res1 = 0 ;
21584 PyObject *swig_obj[1] ;
21585
21586 if (!args) SWIG_fail;
21587 swig_obj[0] = args;
21588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21589 if (!SWIG_IsOK(res1)) {
21590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21591 }
21592 arg1 = reinterpret_cast< wxEvent * >(argp1);
21593 {
21594 PyThreadState* __tstate = wxPyBeginAllowThreads();
21595 result = (int)(arg1)->StopPropagation();
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 resultobj = SWIG_From_int(static_cast< int >(result));
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21607 PyObject *resultobj = 0;
21608 wxEvent *arg1 = (wxEvent *) 0 ;
21609 int arg2 ;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 int val2 ;
21613 int ecode2 = 0 ;
21614 PyObject * obj0 = 0 ;
21615 PyObject * obj1 = 0 ;
21616 char * kwnames[] = {
21617 (char *) "self",(char *) "propagationLevel", NULL
21618 };
21619
21620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21622 if (!SWIG_IsOK(res1)) {
21623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21624 }
21625 arg1 = reinterpret_cast< wxEvent * >(argp1);
21626 ecode2 = SWIG_AsVal_int(obj1, &val2);
21627 if (!SWIG_IsOK(ecode2)) {
21628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21629 }
21630 arg2 = static_cast< int >(val2);
21631 {
21632 PyThreadState* __tstate = wxPyBeginAllowThreads();
21633 (arg1)->ResumePropagation(arg2);
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 resultobj = SWIG_Py_Void();
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21645 PyObject *resultobj = 0;
21646 wxEvent *arg1 = (wxEvent *) 0 ;
21647 wxEvent *result = 0 ;
21648 void *argp1 = 0 ;
21649 int res1 = 0 ;
21650 PyObject *swig_obj[1] ;
21651
21652 if (!args) SWIG_fail;
21653 swig_obj[0] = args;
21654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21655 if (!SWIG_IsOK(res1)) {
21656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21657 }
21658 arg1 = reinterpret_cast< wxEvent * >(argp1);
21659 {
21660 PyThreadState* __tstate = wxPyBeginAllowThreads();
21661 result = (wxEvent *)(arg1)->Clone();
21662 wxPyEndAllowThreads(__tstate);
21663 if (PyErr_Occurred()) SWIG_fail;
21664 }
21665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21666 return resultobj;
21667 fail:
21668 return NULL;
21669 }
21670
21671
21672 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21673 PyObject *obj;
21674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21675 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21676 return SWIG_Py_Void();
21677 }
21678
21679 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21680 PyObject *resultobj = 0;
21681 wxEvent *arg1 = 0 ;
21682 wxPropagationDisabler *result = 0 ;
21683 void *argp1 = 0 ;
21684 int res1 = 0 ;
21685 PyObject * obj0 = 0 ;
21686 char * kwnames[] = {
21687 (char *) "event", NULL
21688 };
21689
21690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21691 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21692 if (!SWIG_IsOK(res1)) {
21693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21694 }
21695 if (!argp1) {
21696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21697 }
21698 arg1 = reinterpret_cast< wxEvent * >(argp1);
21699 {
21700 PyThreadState* __tstate = wxPyBeginAllowThreads();
21701 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21702 wxPyEndAllowThreads(__tstate);
21703 if (PyErr_Occurred()) SWIG_fail;
21704 }
21705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21706 return resultobj;
21707 fail:
21708 return NULL;
21709 }
21710
21711
21712 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21713 PyObject *resultobj = 0;
21714 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21724 }
21725 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 delete arg1;
21729
21730 wxPyEndAllowThreads(__tstate);
21731 if (PyErr_Occurred()) SWIG_fail;
21732 }
21733 resultobj = SWIG_Py_Void();
21734 return resultobj;
21735 fail:
21736 return NULL;
21737 }
21738
21739
21740 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21741 PyObject *obj;
21742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21744 return SWIG_Py_Void();
21745 }
21746
21747 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 return SWIG_Python_InitShadowInstance(args);
21749 }
21750
21751 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21752 PyObject *resultobj = 0;
21753 wxEvent *arg1 = 0 ;
21754 wxPropagateOnce *result = 0 ;
21755 void *argp1 = 0 ;
21756 int res1 = 0 ;
21757 PyObject * obj0 = 0 ;
21758 char * kwnames[] = {
21759 (char *) "event", NULL
21760 };
21761
21762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21763 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21764 if (!SWIG_IsOK(res1)) {
21765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21766 }
21767 if (!argp1) {
21768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21769 }
21770 arg1 = reinterpret_cast< wxEvent * >(argp1);
21771 {
21772 PyThreadState* __tstate = wxPyBeginAllowThreads();
21773 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21778 return resultobj;
21779 fail:
21780 return NULL;
21781 }
21782
21783
21784 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21785 PyObject *resultobj = 0;
21786 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21787 void *argp1 = 0 ;
21788 int res1 = 0 ;
21789 PyObject *swig_obj[1] ;
21790
21791 if (!args) SWIG_fail;
21792 swig_obj[0] = args;
21793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21796 }
21797 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21798 {
21799 PyThreadState* __tstate = wxPyBeginAllowThreads();
21800 delete arg1;
21801
21802 wxPyEndAllowThreads(__tstate);
21803 if (PyErr_Occurred()) SWIG_fail;
21804 }
21805 resultobj = SWIG_Py_Void();
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21813 PyObject *obj;
21814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21815 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21816 return SWIG_Py_Void();
21817 }
21818
21819 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21820 return SWIG_Python_InitShadowInstance(args);
21821 }
21822
21823 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21824 PyObject *resultobj = 0;
21825 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21826 int arg2 = (int) 0 ;
21827 wxCommandEvent *result = 0 ;
21828 int val1 ;
21829 int ecode1 = 0 ;
21830 int val2 ;
21831 int ecode2 = 0 ;
21832 PyObject * obj0 = 0 ;
21833 PyObject * obj1 = 0 ;
21834 char * kwnames[] = {
21835 (char *) "commandType",(char *) "winid", NULL
21836 };
21837
21838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21839 if (obj0) {
21840 ecode1 = SWIG_AsVal_int(obj0, &val1);
21841 if (!SWIG_IsOK(ecode1)) {
21842 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21843 }
21844 arg1 = static_cast< wxEventType >(val1);
21845 }
21846 if (obj1) {
21847 ecode2 = SWIG_AsVal_int(obj1, &val2);
21848 if (!SWIG_IsOK(ecode2)) {
21849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21850 }
21851 arg2 = static_cast< int >(val2);
21852 }
21853 {
21854 PyThreadState* __tstate = wxPyBeginAllowThreads();
21855 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21856 wxPyEndAllowThreads(__tstate);
21857 if (PyErr_Occurred()) SWIG_fail;
21858 }
21859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21860 return resultobj;
21861 fail:
21862 return NULL;
21863 }
21864
21865
21866 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21867 PyObject *resultobj = 0;
21868 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21869 int result;
21870 void *argp1 = 0 ;
21871 int res1 = 0 ;
21872 PyObject *swig_obj[1] ;
21873
21874 if (!args) SWIG_fail;
21875 swig_obj[0] = args;
21876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21877 if (!SWIG_IsOK(res1)) {
21878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21879 }
21880 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21881 {
21882 PyThreadState* __tstate = wxPyBeginAllowThreads();
21883 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21884 wxPyEndAllowThreads(__tstate);
21885 if (PyErr_Occurred()) SWIG_fail;
21886 }
21887 resultobj = SWIG_From_int(static_cast< int >(result));
21888 return resultobj;
21889 fail:
21890 return NULL;
21891 }
21892
21893
21894 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21895 PyObject *resultobj = 0;
21896 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21897 wxString *arg2 = 0 ;
21898 void *argp1 = 0 ;
21899 int res1 = 0 ;
21900 bool temp2 = false ;
21901 PyObject * obj0 = 0 ;
21902 PyObject * obj1 = 0 ;
21903 char * kwnames[] = {
21904 (char *) "self",(char *) "s", NULL
21905 };
21906
21907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21909 if (!SWIG_IsOK(res1)) {
21910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21911 }
21912 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21913 {
21914 arg2 = wxString_in_helper(obj1);
21915 if (arg2 == NULL) SWIG_fail;
21916 temp2 = true;
21917 }
21918 {
21919 PyThreadState* __tstate = wxPyBeginAllowThreads();
21920 (arg1)->SetString((wxString const &)*arg2);
21921 wxPyEndAllowThreads(__tstate);
21922 if (PyErr_Occurred()) SWIG_fail;
21923 }
21924 resultobj = SWIG_Py_Void();
21925 {
21926 if (temp2)
21927 delete arg2;
21928 }
21929 return resultobj;
21930 fail:
21931 {
21932 if (temp2)
21933 delete arg2;
21934 }
21935 return NULL;
21936 }
21937
21938
21939 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21940 PyObject *resultobj = 0;
21941 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21942 wxString result;
21943 void *argp1 = 0 ;
21944 int res1 = 0 ;
21945 PyObject *swig_obj[1] ;
21946
21947 if (!args) SWIG_fail;
21948 swig_obj[0] = args;
21949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21950 if (!SWIG_IsOK(res1)) {
21951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21952 }
21953 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = ((wxCommandEvent const *)arg1)->GetString();
21957 wxPyEndAllowThreads(__tstate);
21958 if (PyErr_Occurred()) SWIG_fail;
21959 }
21960 {
21961 #if wxUSE_UNICODE
21962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21963 #else
21964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21965 #endif
21966 }
21967 return resultobj;
21968 fail:
21969 return NULL;
21970 }
21971
21972
21973 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21974 PyObject *resultobj = 0;
21975 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21976 bool result;
21977 void *argp1 = 0 ;
21978 int res1 = 0 ;
21979 PyObject *swig_obj[1] ;
21980
21981 if (!args) SWIG_fail;
21982 swig_obj[0] = args;
21983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21984 if (!SWIG_IsOK(res1)) {
21985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21986 }
21987 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21988 {
21989 PyThreadState* __tstate = wxPyBeginAllowThreads();
21990 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21991 wxPyEndAllowThreads(__tstate);
21992 if (PyErr_Occurred()) SWIG_fail;
21993 }
21994 {
21995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21996 }
21997 return resultobj;
21998 fail:
21999 return NULL;
22000 }
22001
22002
22003 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22004 PyObject *resultobj = 0;
22005 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22006 bool result;
22007 void *argp1 = 0 ;
22008 int res1 = 0 ;
22009 PyObject *swig_obj[1] ;
22010
22011 if (!args) SWIG_fail;
22012 swig_obj[0] = args;
22013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22014 if (!SWIG_IsOK(res1)) {
22015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22016 }
22017 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22018 {
22019 PyThreadState* __tstate = wxPyBeginAllowThreads();
22020 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22021 wxPyEndAllowThreads(__tstate);
22022 if (PyErr_Occurred()) SWIG_fail;
22023 }
22024 {
22025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22026 }
22027 return resultobj;
22028 fail:
22029 return NULL;
22030 }
22031
22032
22033 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22034 PyObject *resultobj = 0;
22035 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22036 long arg2 ;
22037 void *argp1 = 0 ;
22038 int res1 = 0 ;
22039 long val2 ;
22040 int ecode2 = 0 ;
22041 PyObject * obj0 = 0 ;
22042 PyObject * obj1 = 0 ;
22043 char * kwnames[] = {
22044 (char *) "self",(char *) "extraLong", NULL
22045 };
22046
22047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22049 if (!SWIG_IsOK(res1)) {
22050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22051 }
22052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22053 ecode2 = SWIG_AsVal_long(obj1, &val2);
22054 if (!SWIG_IsOK(ecode2)) {
22055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22056 }
22057 arg2 = static_cast< long >(val2);
22058 {
22059 PyThreadState* __tstate = wxPyBeginAllowThreads();
22060 (arg1)->SetExtraLong(arg2);
22061 wxPyEndAllowThreads(__tstate);
22062 if (PyErr_Occurred()) SWIG_fail;
22063 }
22064 resultobj = SWIG_Py_Void();
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22072 PyObject *resultobj = 0;
22073 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22074 long result;
22075 void *argp1 = 0 ;
22076 int res1 = 0 ;
22077 PyObject *swig_obj[1] ;
22078
22079 if (!args) SWIG_fail;
22080 swig_obj[0] = args;
22081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22082 if (!SWIG_IsOK(res1)) {
22083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22084 }
22085 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 resultobj = SWIG_From_long(static_cast< long >(result));
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22100 PyObject *resultobj = 0;
22101 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22102 int arg2 ;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 int val2 ;
22106 int ecode2 = 0 ;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109 char * kwnames[] = {
22110 (char *) "self",(char *) "i", NULL
22111 };
22112
22113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22115 if (!SWIG_IsOK(res1)) {
22116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22117 }
22118 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22119 ecode2 = SWIG_AsVal_int(obj1, &val2);
22120 if (!SWIG_IsOK(ecode2)) {
22121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22122 }
22123 arg2 = static_cast< int >(val2);
22124 {
22125 PyThreadState* __tstate = wxPyBeginAllowThreads();
22126 (arg1)->SetInt(arg2);
22127 wxPyEndAllowThreads(__tstate);
22128 if (PyErr_Occurred()) SWIG_fail;
22129 }
22130 resultobj = SWIG_Py_Void();
22131 return resultobj;
22132 fail:
22133 return NULL;
22134 }
22135
22136
22137 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22138 PyObject *resultobj = 0;
22139 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22140 int result;
22141 void *argp1 = 0 ;
22142 int res1 = 0 ;
22143 PyObject *swig_obj[1] ;
22144
22145 if (!args) SWIG_fail;
22146 swig_obj[0] = args;
22147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22148 if (!SWIG_IsOK(res1)) {
22149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22150 }
22151 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22152 {
22153 PyThreadState* __tstate = wxPyBeginAllowThreads();
22154 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22155 wxPyEndAllowThreads(__tstate);
22156 if (PyErr_Occurred()) SWIG_fail;
22157 }
22158 resultobj = SWIG_From_int(static_cast< int >(result));
22159 return resultobj;
22160 fail:
22161 return NULL;
22162 }
22163
22164
22165 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22166 PyObject *resultobj = 0;
22167 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22168 PyObject *result = 0 ;
22169 void *argp1 = 0 ;
22170 int res1 = 0 ;
22171 PyObject *swig_obj[1] ;
22172
22173 if (!args) SWIG_fail;
22174 swig_obj[0] = args;
22175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22176 if (!SWIG_IsOK(res1)) {
22177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22178 }
22179 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22180 {
22181 PyThreadState* __tstate = wxPyBeginAllowThreads();
22182 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22183 wxPyEndAllowThreads(__tstate);
22184 if (PyErr_Occurred()) SWIG_fail;
22185 }
22186 resultobj = result;
22187 return resultobj;
22188 fail:
22189 return NULL;
22190 }
22191
22192
22193 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22194 PyObject *resultobj = 0;
22195 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22196 PyObject *arg2 = (PyObject *) 0 ;
22197 void *argp1 = 0 ;
22198 int res1 = 0 ;
22199 PyObject * obj0 = 0 ;
22200 PyObject * obj1 = 0 ;
22201 char * kwnames[] = {
22202 (char *) "self",(char *) "clientData", NULL
22203 };
22204
22205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22207 if (!SWIG_IsOK(res1)) {
22208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22209 }
22210 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22211 arg2 = obj1;
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 wxCommandEvent_SetClientData(arg1,arg2);
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 resultobj = SWIG_Py_Void();
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22226 PyObject *resultobj = 0;
22227 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22228 wxEvent *result = 0 ;
22229 void *argp1 = 0 ;
22230 int res1 = 0 ;
22231 PyObject *swig_obj[1] ;
22232
22233 if (!args) SWIG_fail;
22234 swig_obj[0] = args;
22235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22236 if (!SWIG_IsOK(res1)) {
22237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22238 }
22239 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22254 PyObject *obj;
22255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22256 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22257 return SWIG_Py_Void();
22258 }
22259
22260 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22261 return SWIG_Python_InitShadowInstance(args);
22262 }
22263
22264 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22265 PyObject *resultobj = 0;
22266 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22267 int arg2 = (int) 0 ;
22268 wxNotifyEvent *result = 0 ;
22269 int val1 ;
22270 int ecode1 = 0 ;
22271 int val2 ;
22272 int ecode2 = 0 ;
22273 PyObject * obj0 = 0 ;
22274 PyObject * obj1 = 0 ;
22275 char * kwnames[] = {
22276 (char *) "commandType",(char *) "winid", NULL
22277 };
22278
22279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22280 if (obj0) {
22281 ecode1 = SWIG_AsVal_int(obj0, &val1);
22282 if (!SWIG_IsOK(ecode1)) {
22283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22284 }
22285 arg1 = static_cast< wxEventType >(val1);
22286 }
22287 if (obj1) {
22288 ecode2 = SWIG_AsVal_int(obj1, &val2);
22289 if (!SWIG_IsOK(ecode2)) {
22290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22291 }
22292 arg2 = static_cast< int >(val2);
22293 }
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22308 PyObject *resultobj = 0;
22309 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22310 void *argp1 = 0 ;
22311 int res1 = 0 ;
22312 PyObject *swig_obj[1] ;
22313
22314 if (!args) SWIG_fail;
22315 swig_obj[0] = args;
22316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22317 if (!SWIG_IsOK(res1)) {
22318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22319 }
22320 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22321 {
22322 PyThreadState* __tstate = wxPyBeginAllowThreads();
22323 (arg1)->Veto();
22324 wxPyEndAllowThreads(__tstate);
22325 if (PyErr_Occurred()) SWIG_fail;
22326 }
22327 resultobj = SWIG_Py_Void();
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22335 PyObject *resultobj = 0;
22336 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22337 void *argp1 = 0 ;
22338 int res1 = 0 ;
22339 PyObject *swig_obj[1] ;
22340
22341 if (!args) SWIG_fail;
22342 swig_obj[0] = args;
22343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22344 if (!SWIG_IsOK(res1)) {
22345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22346 }
22347 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 (arg1)->Allow();
22351 wxPyEndAllowThreads(__tstate);
22352 if (PyErr_Occurred()) SWIG_fail;
22353 }
22354 resultobj = SWIG_Py_Void();
22355 return resultobj;
22356 fail:
22357 return NULL;
22358 }
22359
22360
22361 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22362 PyObject *resultobj = 0;
22363 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22364 bool result;
22365 void *argp1 = 0 ;
22366 int res1 = 0 ;
22367 PyObject *swig_obj[1] ;
22368
22369 if (!args) SWIG_fail;
22370 swig_obj[0] = args;
22371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22372 if (!SWIG_IsOK(res1)) {
22373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22374 }
22375 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22376 {
22377 PyThreadState* __tstate = wxPyBeginAllowThreads();
22378 result = (bool)(arg1)->IsAllowed();
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 {
22383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22384 }
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22392 PyObject *obj;
22393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22394 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22395 return SWIG_Py_Void();
22396 }
22397
22398 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22399 return SWIG_Python_InitShadowInstance(args);
22400 }
22401
22402 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22403 PyObject *resultobj = 0;
22404 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22405 int arg2 = (int) 0 ;
22406 int arg3 = (int) 0 ;
22407 int arg4 = (int) 0 ;
22408 wxScrollEvent *result = 0 ;
22409 int val1 ;
22410 int ecode1 = 0 ;
22411 int val2 ;
22412 int ecode2 = 0 ;
22413 int val3 ;
22414 int ecode3 = 0 ;
22415 int val4 ;
22416 int ecode4 = 0 ;
22417 PyObject * obj0 = 0 ;
22418 PyObject * obj1 = 0 ;
22419 PyObject * obj2 = 0 ;
22420 PyObject * obj3 = 0 ;
22421 char * kwnames[] = {
22422 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22423 };
22424
22425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22426 if (obj0) {
22427 ecode1 = SWIG_AsVal_int(obj0, &val1);
22428 if (!SWIG_IsOK(ecode1)) {
22429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22430 }
22431 arg1 = static_cast< wxEventType >(val1);
22432 }
22433 if (obj1) {
22434 ecode2 = SWIG_AsVal_int(obj1, &val2);
22435 if (!SWIG_IsOK(ecode2)) {
22436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22437 }
22438 arg2 = static_cast< int >(val2);
22439 }
22440 if (obj2) {
22441 ecode3 = SWIG_AsVal_int(obj2, &val3);
22442 if (!SWIG_IsOK(ecode3)) {
22443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22444 }
22445 arg3 = static_cast< int >(val3);
22446 }
22447 if (obj3) {
22448 ecode4 = SWIG_AsVal_int(obj3, &val4);
22449 if (!SWIG_IsOK(ecode4)) {
22450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22451 }
22452 arg4 = static_cast< int >(val4);
22453 }
22454 {
22455 PyThreadState* __tstate = wxPyBeginAllowThreads();
22456 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22468 PyObject *resultobj = 0;
22469 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22470 int result;
22471 void *argp1 = 0 ;
22472 int res1 = 0 ;
22473 PyObject *swig_obj[1] ;
22474
22475 if (!args) SWIG_fail;
22476 swig_obj[0] = args;
22477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22478 if (!SWIG_IsOK(res1)) {
22479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22480 }
22481 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22482 {
22483 PyThreadState* __tstate = wxPyBeginAllowThreads();
22484 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22485 wxPyEndAllowThreads(__tstate);
22486 if (PyErr_Occurred()) SWIG_fail;
22487 }
22488 resultobj = SWIG_From_int(static_cast< int >(result));
22489 return resultobj;
22490 fail:
22491 return NULL;
22492 }
22493
22494
22495 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22496 PyObject *resultobj = 0;
22497 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22498 int result;
22499 void *argp1 = 0 ;
22500 int res1 = 0 ;
22501 PyObject *swig_obj[1] ;
22502
22503 if (!args) SWIG_fail;
22504 swig_obj[0] = args;
22505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22508 }
22509 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22510 {
22511 PyThreadState* __tstate = wxPyBeginAllowThreads();
22512 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22513 wxPyEndAllowThreads(__tstate);
22514 if (PyErr_Occurred()) SWIG_fail;
22515 }
22516 resultobj = SWIG_From_int(static_cast< int >(result));
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22526 int arg2 ;
22527 void *argp1 = 0 ;
22528 int res1 = 0 ;
22529 int val2 ;
22530 int ecode2 = 0 ;
22531 PyObject * obj0 = 0 ;
22532 PyObject * obj1 = 0 ;
22533 char * kwnames[] = {
22534 (char *) "self",(char *) "orient", NULL
22535 };
22536
22537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22539 if (!SWIG_IsOK(res1)) {
22540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22541 }
22542 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22543 ecode2 = SWIG_AsVal_int(obj1, &val2);
22544 if (!SWIG_IsOK(ecode2)) {
22545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22546 }
22547 arg2 = static_cast< int >(val2);
22548 {
22549 PyThreadState* __tstate = wxPyBeginAllowThreads();
22550 (arg1)->SetOrientation(arg2);
22551 wxPyEndAllowThreads(__tstate);
22552 if (PyErr_Occurred()) SWIG_fail;
22553 }
22554 resultobj = SWIG_Py_Void();
22555 return resultobj;
22556 fail:
22557 return NULL;
22558 }
22559
22560
22561 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22562 PyObject *resultobj = 0;
22563 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22564 int arg2 ;
22565 void *argp1 = 0 ;
22566 int res1 = 0 ;
22567 int val2 ;
22568 int ecode2 = 0 ;
22569 PyObject * obj0 = 0 ;
22570 PyObject * obj1 = 0 ;
22571 char * kwnames[] = {
22572 (char *) "self",(char *) "pos", NULL
22573 };
22574
22575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22577 if (!SWIG_IsOK(res1)) {
22578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22579 }
22580 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22581 ecode2 = SWIG_AsVal_int(obj1, &val2);
22582 if (!SWIG_IsOK(ecode2)) {
22583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22584 }
22585 arg2 = static_cast< int >(val2);
22586 {
22587 PyThreadState* __tstate = wxPyBeginAllowThreads();
22588 (arg1)->SetPosition(arg2);
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 resultobj = SWIG_Py_Void();
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22600 PyObject *obj;
22601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22602 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22603 return SWIG_Py_Void();
22604 }
22605
22606 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22607 return SWIG_Python_InitShadowInstance(args);
22608 }
22609
22610 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22611 PyObject *resultobj = 0;
22612 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22613 int arg2 = (int) 0 ;
22614 int arg3 = (int) 0 ;
22615 wxScrollWinEvent *result = 0 ;
22616 int val1 ;
22617 int ecode1 = 0 ;
22618 int val2 ;
22619 int ecode2 = 0 ;
22620 int val3 ;
22621 int ecode3 = 0 ;
22622 PyObject * obj0 = 0 ;
22623 PyObject * obj1 = 0 ;
22624 PyObject * obj2 = 0 ;
22625 char * kwnames[] = {
22626 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22627 };
22628
22629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22630 if (obj0) {
22631 ecode1 = SWIG_AsVal_int(obj0, &val1);
22632 if (!SWIG_IsOK(ecode1)) {
22633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22634 }
22635 arg1 = static_cast< wxEventType >(val1);
22636 }
22637 if (obj1) {
22638 ecode2 = SWIG_AsVal_int(obj1, &val2);
22639 if (!SWIG_IsOK(ecode2)) {
22640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22641 }
22642 arg2 = static_cast< int >(val2);
22643 }
22644 if (obj2) {
22645 ecode3 = SWIG_AsVal_int(obj2, &val3);
22646 if (!SWIG_IsOK(ecode3)) {
22647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22648 }
22649 arg3 = static_cast< int >(val3);
22650 }
22651 {
22652 PyThreadState* __tstate = wxPyBeginAllowThreads();
22653 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22654 wxPyEndAllowThreads(__tstate);
22655 if (PyErr_Occurred()) SWIG_fail;
22656 }
22657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22658 return resultobj;
22659 fail:
22660 return NULL;
22661 }
22662
22663
22664 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22665 PyObject *resultobj = 0;
22666 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22667 int result;
22668 void *argp1 = 0 ;
22669 int res1 = 0 ;
22670 PyObject *swig_obj[1] ;
22671
22672 if (!args) SWIG_fail;
22673 swig_obj[0] = args;
22674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22675 if (!SWIG_IsOK(res1)) {
22676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22677 }
22678 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22679 {
22680 PyThreadState* __tstate = wxPyBeginAllowThreads();
22681 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22682 wxPyEndAllowThreads(__tstate);
22683 if (PyErr_Occurred()) SWIG_fail;
22684 }
22685 resultobj = SWIG_From_int(static_cast< int >(result));
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22695 int result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22705 }
22706 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22707 {
22708 PyThreadState* __tstate = wxPyBeginAllowThreads();
22709 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22710 wxPyEndAllowThreads(__tstate);
22711 if (PyErr_Occurred()) SWIG_fail;
22712 }
22713 resultobj = SWIG_From_int(static_cast< int >(result));
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22721 PyObject *resultobj = 0;
22722 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22723 int arg2 ;
22724 void *argp1 = 0 ;
22725 int res1 = 0 ;
22726 int val2 ;
22727 int ecode2 = 0 ;
22728 PyObject * obj0 = 0 ;
22729 PyObject * obj1 = 0 ;
22730 char * kwnames[] = {
22731 (char *) "self",(char *) "orient", NULL
22732 };
22733
22734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22736 if (!SWIG_IsOK(res1)) {
22737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22738 }
22739 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22740 ecode2 = SWIG_AsVal_int(obj1, &val2);
22741 if (!SWIG_IsOK(ecode2)) {
22742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22743 }
22744 arg2 = static_cast< int >(val2);
22745 {
22746 PyThreadState* __tstate = wxPyBeginAllowThreads();
22747 (arg1)->SetOrientation(arg2);
22748 wxPyEndAllowThreads(__tstate);
22749 if (PyErr_Occurred()) SWIG_fail;
22750 }
22751 resultobj = SWIG_Py_Void();
22752 return resultobj;
22753 fail:
22754 return NULL;
22755 }
22756
22757
22758 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22759 PyObject *resultobj = 0;
22760 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22761 int arg2 ;
22762 void *argp1 = 0 ;
22763 int res1 = 0 ;
22764 int val2 ;
22765 int ecode2 = 0 ;
22766 PyObject * obj0 = 0 ;
22767 PyObject * obj1 = 0 ;
22768 char * kwnames[] = {
22769 (char *) "self",(char *) "pos", NULL
22770 };
22771
22772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22774 if (!SWIG_IsOK(res1)) {
22775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22776 }
22777 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22778 ecode2 = SWIG_AsVal_int(obj1, &val2);
22779 if (!SWIG_IsOK(ecode2)) {
22780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22781 }
22782 arg2 = static_cast< int >(val2);
22783 {
22784 PyThreadState* __tstate = wxPyBeginAllowThreads();
22785 (arg1)->SetPosition(arg2);
22786 wxPyEndAllowThreads(__tstate);
22787 if (PyErr_Occurred()) SWIG_fail;
22788 }
22789 resultobj = SWIG_Py_Void();
22790 return resultobj;
22791 fail:
22792 return NULL;
22793 }
22794
22795
22796 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22797 PyObject *obj;
22798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22799 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22800 return SWIG_Py_Void();
22801 }
22802
22803 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22804 return SWIG_Python_InitShadowInstance(args);
22805 }
22806
22807 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22808 PyObject *resultobj = 0;
22809 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22810 wxMouseEvent *result = 0 ;
22811 int val1 ;
22812 int ecode1 = 0 ;
22813 PyObject * obj0 = 0 ;
22814 char * kwnames[] = {
22815 (char *) "mouseType", NULL
22816 };
22817
22818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22819 if (obj0) {
22820 ecode1 = SWIG_AsVal_int(obj0, &val1);
22821 if (!SWIG_IsOK(ecode1)) {
22822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22823 }
22824 arg1 = static_cast< wxEventType >(val1);
22825 }
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22833 return resultobj;
22834 fail:
22835 return NULL;
22836 }
22837
22838
22839 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22840 PyObject *resultobj = 0;
22841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22842 bool result;
22843 void *argp1 = 0 ;
22844 int res1 = 0 ;
22845 PyObject *swig_obj[1] ;
22846
22847 if (!args) SWIG_fail;
22848 swig_obj[0] = args;
22849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22850 if (!SWIG_IsOK(res1)) {
22851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22852 }
22853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22854 {
22855 PyThreadState* __tstate = wxPyBeginAllowThreads();
22856 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 {
22861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22862 }
22863 return resultobj;
22864 fail:
22865 return NULL;
22866 }
22867
22868
22869 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22870 PyObject *resultobj = 0;
22871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22872 int arg2 = (int) wxMOUSE_BTN_ANY ;
22873 bool result;
22874 void *argp1 = 0 ;
22875 int res1 = 0 ;
22876 int val2 ;
22877 int ecode2 = 0 ;
22878 PyObject * obj0 = 0 ;
22879 PyObject * obj1 = 0 ;
22880 char * kwnames[] = {
22881 (char *) "self",(char *) "but", NULL
22882 };
22883
22884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22886 if (!SWIG_IsOK(res1)) {
22887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22888 }
22889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22890 if (obj1) {
22891 ecode2 = SWIG_AsVal_int(obj1, &val2);
22892 if (!SWIG_IsOK(ecode2)) {
22893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22894 }
22895 arg2 = static_cast< int >(val2);
22896 }
22897 {
22898 PyThreadState* __tstate = wxPyBeginAllowThreads();
22899 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22900 wxPyEndAllowThreads(__tstate);
22901 if (PyErr_Occurred()) SWIG_fail;
22902 }
22903 {
22904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22905 }
22906 return resultobj;
22907 fail:
22908 return NULL;
22909 }
22910
22911
22912 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22913 PyObject *resultobj = 0;
22914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22915 int arg2 = (int) wxMOUSE_BTN_ANY ;
22916 bool result;
22917 void *argp1 = 0 ;
22918 int res1 = 0 ;
22919 int val2 ;
22920 int ecode2 = 0 ;
22921 PyObject * obj0 = 0 ;
22922 PyObject * obj1 = 0 ;
22923 char * kwnames[] = {
22924 (char *) "self",(char *) "but", NULL
22925 };
22926
22927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22929 if (!SWIG_IsOK(res1)) {
22930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22931 }
22932 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22933 if (obj1) {
22934 ecode2 = SWIG_AsVal_int(obj1, &val2);
22935 if (!SWIG_IsOK(ecode2)) {
22936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22937 }
22938 arg2 = static_cast< int >(val2);
22939 }
22940 {
22941 PyThreadState* __tstate = wxPyBeginAllowThreads();
22942 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22943 wxPyEndAllowThreads(__tstate);
22944 if (PyErr_Occurred()) SWIG_fail;
22945 }
22946 {
22947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22948 }
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22956 PyObject *resultobj = 0;
22957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22958 int arg2 = (int) wxMOUSE_BTN_ANY ;
22959 bool result;
22960 void *argp1 = 0 ;
22961 int res1 = 0 ;
22962 int val2 ;
22963 int ecode2 = 0 ;
22964 PyObject * obj0 = 0 ;
22965 PyObject * obj1 = 0 ;
22966 char * kwnames[] = {
22967 (char *) "self",(char *) "but", NULL
22968 };
22969
22970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22972 if (!SWIG_IsOK(res1)) {
22973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22974 }
22975 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22976 if (obj1) {
22977 ecode2 = SWIG_AsVal_int(obj1, &val2);
22978 if (!SWIG_IsOK(ecode2)) {
22979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22980 }
22981 arg2 = static_cast< int >(val2);
22982 }
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22986 wxPyEndAllowThreads(__tstate);
22987 if (PyErr_Occurred()) SWIG_fail;
22988 }
22989 {
22990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22991 }
22992 return resultobj;
22993 fail:
22994 return NULL;
22995 }
22996
22997
22998 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22999 PyObject *resultobj = 0;
23000 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23001 int arg2 ;
23002 bool result;
23003 void *argp1 = 0 ;
23004 int res1 = 0 ;
23005 int val2 ;
23006 int ecode2 = 0 ;
23007 PyObject * obj0 = 0 ;
23008 PyObject * obj1 = 0 ;
23009 char * kwnames[] = {
23010 (char *) "self",(char *) "button", NULL
23011 };
23012
23013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23015 if (!SWIG_IsOK(res1)) {
23016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23017 }
23018 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23019 ecode2 = SWIG_AsVal_int(obj1, &val2);
23020 if (!SWIG_IsOK(ecode2)) {
23021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23022 }
23023 arg2 = static_cast< int >(val2);
23024 {
23025 PyThreadState* __tstate = wxPyBeginAllowThreads();
23026 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23027 wxPyEndAllowThreads(__tstate);
23028 if (PyErr_Occurred()) SWIG_fail;
23029 }
23030 {
23031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23032 }
23033 return resultobj;
23034 fail:
23035 return NULL;
23036 }
23037
23038
23039 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23040 PyObject *resultobj = 0;
23041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23042 int arg2 ;
23043 bool result;
23044 void *argp1 = 0 ;
23045 int res1 = 0 ;
23046 int val2 ;
23047 int ecode2 = 0 ;
23048 PyObject * obj0 = 0 ;
23049 PyObject * obj1 = 0 ;
23050 char * kwnames[] = {
23051 (char *) "self",(char *) "but", NULL
23052 };
23053
23054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23056 if (!SWIG_IsOK(res1)) {
23057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23058 }
23059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23060 ecode2 = SWIG_AsVal_int(obj1, &val2);
23061 if (!SWIG_IsOK(ecode2)) {
23062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23063 }
23064 arg2 = static_cast< int >(val2);
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23068 wxPyEndAllowThreads(__tstate);
23069 if (PyErr_Occurred()) SWIG_fail;
23070 }
23071 {
23072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23073 }
23074 return resultobj;
23075 fail:
23076 return NULL;
23077 }
23078
23079
23080 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23081 PyObject *resultobj = 0;
23082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23083 int result;
23084 void *argp1 = 0 ;
23085 int res1 = 0 ;
23086 PyObject *swig_obj[1] ;
23087
23088 if (!args) SWIG_fail;
23089 swig_obj[0] = args;
23090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23093 }
23094 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23095 {
23096 PyThreadState* __tstate = wxPyBeginAllowThreads();
23097 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23098 wxPyEndAllowThreads(__tstate);
23099 if (PyErr_Occurred()) SWIG_fail;
23100 }
23101 resultobj = SWIG_From_int(static_cast< int >(result));
23102 return resultobj;
23103 fail:
23104 return NULL;
23105 }
23106
23107
23108 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 PyObject *resultobj = 0;
23110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23111 bool result;
23112 void *argp1 = 0 ;
23113 int res1 = 0 ;
23114 PyObject *swig_obj[1] ;
23115
23116 if (!args) SWIG_fail;
23117 swig_obj[0] = args;
23118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23119 if (!SWIG_IsOK(res1)) {
23120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23121 }
23122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 {
23130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23131 }
23132 return resultobj;
23133 fail:
23134 return NULL;
23135 }
23136
23137
23138 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23139 PyObject *resultobj = 0;
23140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23141 bool result;
23142 void *argp1 = 0 ;
23143 int res1 = 0 ;
23144 PyObject *swig_obj[1] ;
23145
23146 if (!args) SWIG_fail;
23147 swig_obj[0] = args;
23148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23149 if (!SWIG_IsOK(res1)) {
23150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23151 }
23152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23156 wxPyEndAllowThreads(__tstate);
23157 if (PyErr_Occurred()) SWIG_fail;
23158 }
23159 {
23160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23161 }
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23169 PyObject *resultobj = 0;
23170 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23171 bool result;
23172 void *argp1 = 0 ;
23173 int res1 = 0 ;
23174 PyObject *swig_obj[1] ;
23175
23176 if (!args) SWIG_fail;
23177 swig_obj[0] = args;
23178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23179 if (!SWIG_IsOK(res1)) {
23180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23181 }
23182 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23183 {
23184 PyThreadState* __tstate = wxPyBeginAllowThreads();
23185 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23186 wxPyEndAllowThreads(__tstate);
23187 if (PyErr_Occurred()) SWIG_fail;
23188 }
23189 {
23190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23191 }
23192 return resultobj;
23193 fail:
23194 return NULL;
23195 }
23196
23197
23198 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23199 PyObject *resultobj = 0;
23200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23201 bool result;
23202 void *argp1 = 0 ;
23203 int res1 = 0 ;
23204 PyObject *swig_obj[1] ;
23205
23206 if (!args) SWIG_fail;
23207 swig_obj[0] = args;
23208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23209 if (!SWIG_IsOK(res1)) {
23210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23211 }
23212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23213 {
23214 PyThreadState* __tstate = wxPyBeginAllowThreads();
23215 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23216 wxPyEndAllowThreads(__tstate);
23217 if (PyErr_Occurred()) SWIG_fail;
23218 }
23219 {
23220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23221 }
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229 PyObject *resultobj = 0;
23230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23231 bool result;
23232 void *argp1 = 0 ;
23233 int res1 = 0 ;
23234 PyObject *swig_obj[1] ;
23235
23236 if (!args) SWIG_fail;
23237 swig_obj[0] = args;
23238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23239 if (!SWIG_IsOK(res1)) {
23240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23241 }
23242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 {
23250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23251 }
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23259 PyObject *resultobj = 0;
23260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23261 bool result;
23262 void *argp1 = 0 ;
23263 int res1 = 0 ;
23264 PyObject *swig_obj[1] ;
23265
23266 if (!args) SWIG_fail;
23267 swig_obj[0] = args;
23268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23269 if (!SWIG_IsOK(res1)) {
23270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23271 }
23272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23273 {
23274 PyThreadState* __tstate = wxPyBeginAllowThreads();
23275 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23276 wxPyEndAllowThreads(__tstate);
23277 if (PyErr_Occurred()) SWIG_fail;
23278 }
23279 {
23280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23281 }
23282 return resultobj;
23283 fail:
23284 return NULL;
23285 }
23286
23287
23288 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23289 PyObject *resultobj = 0;
23290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23291 bool result;
23292 void *argp1 = 0 ;
23293 int res1 = 0 ;
23294 PyObject *swig_obj[1] ;
23295
23296 if (!args) SWIG_fail;
23297 swig_obj[0] = args;
23298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23299 if (!SWIG_IsOK(res1)) {
23300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23301 }
23302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23303 {
23304 PyThreadState* __tstate = wxPyBeginAllowThreads();
23305 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 {
23310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23311 }
23312 return resultobj;
23313 fail:
23314 return NULL;
23315 }
23316
23317
23318 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23319 PyObject *resultobj = 0;
23320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23321 bool result;
23322 void *argp1 = 0 ;
23323 int res1 = 0 ;
23324 PyObject *swig_obj[1] ;
23325
23326 if (!args) SWIG_fail;
23327 swig_obj[0] = args;
23328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23329 if (!SWIG_IsOK(res1)) {
23330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23331 }
23332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23333 {
23334 PyThreadState* __tstate = wxPyBeginAllowThreads();
23335 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23336 wxPyEndAllowThreads(__tstate);
23337 if (PyErr_Occurred()) SWIG_fail;
23338 }
23339 {
23340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23341 }
23342 return resultobj;
23343 fail:
23344 return NULL;
23345 }
23346
23347
23348 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23349 PyObject *resultobj = 0;
23350 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23351 bool result;
23352 void *argp1 = 0 ;
23353 int res1 = 0 ;
23354 PyObject *swig_obj[1] ;
23355
23356 if (!args) SWIG_fail;
23357 swig_obj[0] = args;
23358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23359 if (!SWIG_IsOK(res1)) {
23360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23361 }
23362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 {
23370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23371 }
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379 PyObject *resultobj = 0;
23380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23381 bool result;
23382 void *argp1 = 0 ;
23383 int res1 = 0 ;
23384 PyObject *swig_obj[1] ;
23385
23386 if (!args) SWIG_fail;
23387 swig_obj[0] = args;
23388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23389 if (!SWIG_IsOK(res1)) {
23390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23391 }
23392 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23396 wxPyEndAllowThreads(__tstate);
23397 if (PyErr_Occurred()) SWIG_fail;
23398 }
23399 {
23400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23401 }
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23409 PyObject *resultobj = 0;
23410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23411 bool result;
23412 void *argp1 = 0 ;
23413 int res1 = 0 ;
23414 PyObject *swig_obj[1] ;
23415
23416 if (!args) SWIG_fail;
23417 swig_obj[0] = args;
23418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23419 if (!SWIG_IsOK(res1)) {
23420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23421 }
23422 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23426 wxPyEndAllowThreads(__tstate);
23427 if (PyErr_Occurred()) SWIG_fail;
23428 }
23429 {
23430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23431 }
23432 return resultobj;
23433 fail:
23434 return NULL;
23435 }
23436
23437
23438 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23439 PyObject *resultobj = 0;
23440 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23441 bool result;
23442 void *argp1 = 0 ;
23443 int res1 = 0 ;
23444 PyObject *swig_obj[1] ;
23445
23446 if (!args) SWIG_fail;
23447 swig_obj[0] = args;
23448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23449 if (!SWIG_IsOK(res1)) {
23450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23451 }
23452 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23453 {
23454 PyThreadState* __tstate = wxPyBeginAllowThreads();
23455 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23456 wxPyEndAllowThreads(__tstate);
23457 if (PyErr_Occurred()) SWIG_fail;
23458 }
23459 {
23460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23461 }
23462 return resultobj;
23463 fail:
23464 return NULL;
23465 }
23466
23467
23468 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469 PyObject *resultobj = 0;
23470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23471 bool result;
23472 void *argp1 = 0 ;
23473 int res1 = 0 ;
23474 PyObject *swig_obj[1] ;
23475
23476 if (!args) SWIG_fail;
23477 swig_obj[0] = args;
23478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23479 if (!SWIG_IsOK(res1)) {
23480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23481 }
23482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 {
23490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23491 }
23492 return resultobj;
23493 fail:
23494 return NULL;
23495 }
23496
23497
23498 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23499 PyObject *resultobj = 0;
23500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23501 bool result;
23502 void *argp1 = 0 ;
23503 int res1 = 0 ;
23504 PyObject *swig_obj[1] ;
23505
23506 if (!args) SWIG_fail;
23507 swig_obj[0] = args;
23508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23509 if (!SWIG_IsOK(res1)) {
23510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23511 }
23512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23513 {
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23516 wxPyEndAllowThreads(__tstate);
23517 if (PyErr_Occurred()) SWIG_fail;
23518 }
23519 {
23520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23521 }
23522 return resultobj;
23523 fail:
23524 return NULL;
23525 }
23526
23527
23528 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23529 PyObject *resultobj = 0;
23530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23531 bool result;
23532 void *argp1 = 0 ;
23533 int res1 = 0 ;
23534 PyObject *swig_obj[1] ;
23535
23536 if (!args) SWIG_fail;
23537 swig_obj[0] = args;
23538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23539 if (!SWIG_IsOK(res1)) {
23540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23541 }
23542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (bool)(arg1)->LeftIsDown();
23546 wxPyEndAllowThreads(__tstate);
23547 if (PyErr_Occurred()) SWIG_fail;
23548 }
23549 {
23550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23551 }
23552 return resultobj;
23553 fail:
23554 return NULL;
23555 }
23556
23557
23558 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23559 PyObject *resultobj = 0;
23560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23561 bool result;
23562 void *argp1 = 0 ;
23563 int res1 = 0 ;
23564 PyObject *swig_obj[1] ;
23565
23566 if (!args) SWIG_fail;
23567 swig_obj[0] = args;
23568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23569 if (!SWIG_IsOK(res1)) {
23570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23571 }
23572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = (bool)(arg1)->MiddleIsDown();
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 {
23580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23581 }
23582 return resultobj;
23583 fail:
23584 return NULL;
23585 }
23586
23587
23588 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23589 PyObject *resultobj = 0;
23590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23591 bool result;
23592 void *argp1 = 0 ;
23593 int res1 = 0 ;
23594 PyObject *swig_obj[1] ;
23595
23596 if (!args) SWIG_fail;
23597 swig_obj[0] = args;
23598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23599 if (!SWIG_IsOK(res1)) {
23600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23601 }
23602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23603 {
23604 PyThreadState* __tstate = wxPyBeginAllowThreads();
23605 result = (bool)(arg1)->RightIsDown();
23606 wxPyEndAllowThreads(__tstate);
23607 if (PyErr_Occurred()) SWIG_fail;
23608 }
23609 {
23610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23611 }
23612 return resultobj;
23613 fail:
23614 return NULL;
23615 }
23616
23617
23618 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23619 PyObject *resultobj = 0;
23620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23621 bool result;
23622 void *argp1 = 0 ;
23623 int res1 = 0 ;
23624 PyObject *swig_obj[1] ;
23625
23626 if (!args) SWIG_fail;
23627 swig_obj[0] = args;
23628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23629 if (!SWIG_IsOK(res1)) {
23630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23631 }
23632 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23633 {
23634 PyThreadState* __tstate = wxPyBeginAllowThreads();
23635 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 {
23640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23641 }
23642 return resultobj;
23643 fail:
23644 return NULL;
23645 }
23646
23647
23648 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23649 PyObject *resultobj = 0;
23650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23651 bool result;
23652 void *argp1 = 0 ;
23653 int res1 = 0 ;
23654 PyObject *swig_obj[1] ;
23655
23656 if (!args) SWIG_fail;
23657 swig_obj[0] = args;
23658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23659 if (!SWIG_IsOK(res1)) {
23660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23661 }
23662 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23666 wxPyEndAllowThreads(__tstate);
23667 if (PyErr_Occurred()) SWIG_fail;
23668 }
23669 {
23670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23671 }
23672 return resultobj;
23673 fail:
23674 return NULL;
23675 }
23676
23677
23678 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23679 PyObject *resultobj = 0;
23680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23681 bool result;
23682 void *argp1 = 0 ;
23683 int res1 = 0 ;
23684 PyObject *swig_obj[1] ;
23685
23686 if (!args) SWIG_fail;
23687 swig_obj[0] = args;
23688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23689 if (!SWIG_IsOK(res1)) {
23690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23691 }
23692 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23693 {
23694 PyThreadState* __tstate = wxPyBeginAllowThreads();
23695 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 {
23700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23701 }
23702 return resultobj;
23703 fail:
23704 return NULL;
23705 }
23706
23707
23708 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23709 PyObject *resultobj = 0;
23710 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23711 bool result;
23712 void *argp1 = 0 ;
23713 int res1 = 0 ;
23714 PyObject *swig_obj[1] ;
23715
23716 if (!args) SWIG_fail;
23717 swig_obj[0] = args;
23718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23719 if (!SWIG_IsOK(res1)) {
23720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23721 }
23722 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23723 {
23724 PyThreadState* __tstate = wxPyBeginAllowThreads();
23725 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23726 wxPyEndAllowThreads(__tstate);
23727 if (PyErr_Occurred()) SWIG_fail;
23728 }
23729 {
23730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23731 }
23732 return resultobj;
23733 fail:
23734 return NULL;
23735 }
23736
23737
23738 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23739 PyObject *resultobj = 0;
23740 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23741 wxPoint result;
23742 void *argp1 = 0 ;
23743 int res1 = 0 ;
23744 PyObject *swig_obj[1] ;
23745
23746 if (!args) SWIG_fail;
23747 swig_obj[0] = args;
23748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23749 if (!SWIG_IsOK(res1)) {
23750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23751 }
23752 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 result = (arg1)->GetPosition();
23756 wxPyEndAllowThreads(__tstate);
23757 if (PyErr_Occurred()) SWIG_fail;
23758 }
23759 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23760 return resultobj;
23761 fail:
23762 return NULL;
23763 }
23764
23765
23766 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23767 PyObject *resultobj = 0;
23768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23769 long *arg2 = (long *) 0 ;
23770 long *arg3 = (long *) 0 ;
23771 void *argp1 = 0 ;
23772 int res1 = 0 ;
23773 long temp2 ;
23774 int res2 = SWIG_TMPOBJ ;
23775 long temp3 ;
23776 int res3 = SWIG_TMPOBJ ;
23777 PyObject *swig_obj[1] ;
23778
23779 arg2 = &temp2;
23780 arg3 = &temp3;
23781 if (!args) SWIG_fail;
23782 swig_obj[0] = args;
23783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23784 if (!SWIG_IsOK(res1)) {
23785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23786 }
23787 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23788 {
23789 PyThreadState* __tstate = wxPyBeginAllowThreads();
23790 (arg1)->GetPosition(arg2,arg3);
23791 wxPyEndAllowThreads(__tstate);
23792 if (PyErr_Occurred()) SWIG_fail;
23793 }
23794 resultobj = SWIG_Py_Void();
23795 if (SWIG_IsTmpObj(res2)) {
23796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23797 } else {
23798 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23800 }
23801 if (SWIG_IsTmpObj(res3)) {
23802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23803 } else {
23804 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23806 }
23807 return resultobj;
23808 fail:
23809 return NULL;
23810 }
23811
23812
23813 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23814 PyObject *resultobj = 0;
23815 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23816 wxDC *arg2 = 0 ;
23817 wxPoint result;
23818 void *argp1 = 0 ;
23819 int res1 = 0 ;
23820 void *argp2 = 0 ;
23821 int res2 = 0 ;
23822 PyObject * obj0 = 0 ;
23823 PyObject * obj1 = 0 ;
23824 char * kwnames[] = {
23825 (char *) "self",(char *) "dc", NULL
23826 };
23827
23828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23830 if (!SWIG_IsOK(res1)) {
23831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23832 }
23833 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23834 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23835 if (!SWIG_IsOK(res2)) {
23836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23837 }
23838 if (!argp2) {
23839 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23840 }
23841 arg2 = reinterpret_cast< wxDC * >(argp2);
23842 {
23843 PyThreadState* __tstate = wxPyBeginAllowThreads();
23844 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23845 wxPyEndAllowThreads(__tstate);
23846 if (PyErr_Occurred()) SWIG_fail;
23847 }
23848 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23856 PyObject *resultobj = 0;
23857 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23858 int result;
23859 void *argp1 = 0 ;
23860 int res1 = 0 ;
23861 PyObject *swig_obj[1] ;
23862
23863 if (!args) SWIG_fail;
23864 swig_obj[0] = args;
23865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23866 if (!SWIG_IsOK(res1)) {
23867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23868 }
23869 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (int)((wxMouseEvent const *)arg1)->GetX();
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_From_int(static_cast< int >(result));
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *resultobj = 0;
23885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23886 int result;
23887 void *argp1 = 0 ;
23888 int res1 = 0 ;
23889 PyObject *swig_obj[1] ;
23890
23891 if (!args) SWIG_fail;
23892 swig_obj[0] = args;
23893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23894 if (!SWIG_IsOK(res1)) {
23895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23896 }
23897 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23898 {
23899 PyThreadState* __tstate = wxPyBeginAllowThreads();
23900 result = (int)((wxMouseEvent const *)arg1)->GetY();
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 resultobj = SWIG_From_int(static_cast< int >(result));
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23912 PyObject *resultobj = 0;
23913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23914 int result;
23915 void *argp1 = 0 ;
23916 int res1 = 0 ;
23917 PyObject *swig_obj[1] ;
23918
23919 if (!args) SWIG_fail;
23920 swig_obj[0] = args;
23921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23922 if (!SWIG_IsOK(res1)) {
23923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23924 }
23925 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23929 wxPyEndAllowThreads(__tstate);
23930 if (PyErr_Occurred()) SWIG_fail;
23931 }
23932 resultobj = SWIG_From_int(static_cast< int >(result));
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23940 PyObject *resultobj = 0;
23941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23942 int result;
23943 void *argp1 = 0 ;
23944 int res1 = 0 ;
23945 PyObject *swig_obj[1] ;
23946
23947 if (!args) SWIG_fail;
23948 swig_obj[0] = args;
23949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23950 if (!SWIG_IsOK(res1)) {
23951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23952 }
23953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_From_int(static_cast< int >(result));
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23968 PyObject *resultobj = 0;
23969 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23970 int result;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 PyObject *swig_obj[1] ;
23974
23975 if (!args) SWIG_fail;
23976 swig_obj[0] = args;
23977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23978 if (!SWIG_IsOK(res1)) {
23979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23980 }
23981 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23982 {
23983 PyThreadState* __tstate = wxPyBeginAllowThreads();
23984 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 resultobj = SWIG_From_int(static_cast< int >(result));
23989 return resultobj;
23990 fail:
23991 return NULL;
23992 }
23993
23994
23995 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23996 PyObject *resultobj = 0;
23997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23998 int result;
23999 void *argp1 = 0 ;
24000 int res1 = 0 ;
24001 PyObject *swig_obj[1] ;
24002
24003 if (!args) SWIG_fail;
24004 swig_obj[0] = args;
24005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24006 if (!SWIG_IsOK(res1)) {
24007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24008 }
24009 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24010 {
24011 PyThreadState* __tstate = wxPyBeginAllowThreads();
24012 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24013 wxPyEndAllowThreads(__tstate);
24014 if (PyErr_Occurred()) SWIG_fail;
24015 }
24016 resultobj = SWIG_From_int(static_cast< int >(result));
24017 return resultobj;
24018 fail:
24019 return NULL;
24020 }
24021
24022
24023 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24024 PyObject *resultobj = 0;
24025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24026 bool result;
24027 void *argp1 = 0 ;
24028 int res1 = 0 ;
24029 PyObject *swig_obj[1] ;
24030
24031 if (!args) SWIG_fail;
24032 swig_obj[0] = args;
24033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24034 if (!SWIG_IsOK(res1)) {
24035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24036 }
24037 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24038 {
24039 PyThreadState* __tstate = wxPyBeginAllowThreads();
24040 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 {
24045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24046 }
24047 return resultobj;
24048 fail:
24049 return NULL;
24050 }
24051
24052
24053 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24054 PyObject *resultobj = 0;
24055 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24056 int arg2 ;
24057 void *argp1 = 0 ;
24058 int res1 = 0 ;
24059 int val2 ;
24060 int ecode2 = 0 ;
24061 PyObject *swig_obj[2] ;
24062
24063 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24065 if (!SWIG_IsOK(res1)) {
24066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24067 }
24068 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24069 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24070 if (!SWIG_IsOK(ecode2)) {
24071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24072 }
24073 arg2 = static_cast< int >(val2);
24074 if (arg1) (arg1)->m_x = arg2;
24075
24076 resultobj = SWIG_Py_Void();
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24084 PyObject *resultobj = 0;
24085 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24086 int result;
24087 void *argp1 = 0 ;
24088 int res1 = 0 ;
24089 PyObject *swig_obj[1] ;
24090
24091 if (!args) SWIG_fail;
24092 swig_obj[0] = args;
24093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24094 if (!SWIG_IsOK(res1)) {
24095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24096 }
24097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24098 result = (int) ((arg1)->m_x);
24099 resultobj = SWIG_From_int(static_cast< int >(result));
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24107 PyObject *resultobj = 0;
24108 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24109 int arg2 ;
24110 void *argp1 = 0 ;
24111 int res1 = 0 ;
24112 int val2 ;
24113 int ecode2 = 0 ;
24114 PyObject *swig_obj[2] ;
24115
24116 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24118 if (!SWIG_IsOK(res1)) {
24119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24120 }
24121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24122 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24123 if (!SWIG_IsOK(ecode2)) {
24124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24125 }
24126 arg2 = static_cast< int >(val2);
24127 if (arg1) (arg1)->m_y = arg2;
24128
24129 resultobj = SWIG_Py_Void();
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24137 PyObject *resultobj = 0;
24138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24139 int result;
24140 void *argp1 = 0 ;
24141 int res1 = 0 ;
24142 PyObject *swig_obj[1] ;
24143
24144 if (!args) SWIG_fail;
24145 swig_obj[0] = args;
24146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24147 if (!SWIG_IsOK(res1)) {
24148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24149 }
24150 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24151 result = (int) ((arg1)->m_y);
24152 resultobj = SWIG_From_int(static_cast< int >(result));
24153 return resultobj;
24154 fail:
24155 return NULL;
24156 }
24157
24158
24159 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24160 PyObject *resultobj = 0;
24161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24162 bool arg2 ;
24163 void *argp1 = 0 ;
24164 int res1 = 0 ;
24165 bool val2 ;
24166 int ecode2 = 0 ;
24167 PyObject *swig_obj[2] ;
24168
24169 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24171 if (!SWIG_IsOK(res1)) {
24172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24173 }
24174 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24175 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24176 if (!SWIG_IsOK(ecode2)) {
24177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24178 }
24179 arg2 = static_cast< bool >(val2);
24180 if (arg1) (arg1)->m_leftDown = arg2;
24181
24182 resultobj = SWIG_Py_Void();
24183 return resultobj;
24184 fail:
24185 return NULL;
24186 }
24187
24188
24189 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24190 PyObject *resultobj = 0;
24191 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24192 bool result;
24193 void *argp1 = 0 ;
24194 int res1 = 0 ;
24195 PyObject *swig_obj[1] ;
24196
24197 if (!args) SWIG_fail;
24198 swig_obj[0] = args;
24199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24200 if (!SWIG_IsOK(res1)) {
24201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24202 }
24203 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24204 result = (bool) ((arg1)->m_leftDown);
24205 {
24206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24207 }
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24215 PyObject *resultobj = 0;
24216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24217 bool arg2 ;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 bool val2 ;
24221 int ecode2 = 0 ;
24222 PyObject *swig_obj[2] ;
24223
24224 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24228 }
24229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24230 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24231 if (!SWIG_IsOK(ecode2)) {
24232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24233 }
24234 arg2 = static_cast< bool >(val2);
24235 if (arg1) (arg1)->m_middleDown = arg2;
24236
24237 resultobj = SWIG_Py_Void();
24238 return resultobj;
24239 fail:
24240 return NULL;
24241 }
24242
24243
24244 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24245 PyObject *resultobj = 0;
24246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24247 bool result;
24248 void *argp1 = 0 ;
24249 int res1 = 0 ;
24250 PyObject *swig_obj[1] ;
24251
24252 if (!args) SWIG_fail;
24253 swig_obj[0] = args;
24254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24255 if (!SWIG_IsOK(res1)) {
24256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24257 }
24258 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24259 result = (bool) ((arg1)->m_middleDown);
24260 {
24261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24262 }
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24270 PyObject *resultobj = 0;
24271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24272 bool arg2 ;
24273 void *argp1 = 0 ;
24274 int res1 = 0 ;
24275 bool val2 ;
24276 int ecode2 = 0 ;
24277 PyObject *swig_obj[2] ;
24278
24279 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24281 if (!SWIG_IsOK(res1)) {
24282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24283 }
24284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24285 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24286 if (!SWIG_IsOK(ecode2)) {
24287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24288 }
24289 arg2 = static_cast< bool >(val2);
24290 if (arg1) (arg1)->m_rightDown = arg2;
24291
24292 resultobj = SWIG_Py_Void();
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24300 PyObject *resultobj = 0;
24301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24302 bool result;
24303 void *argp1 = 0 ;
24304 int res1 = 0 ;
24305 PyObject *swig_obj[1] ;
24306
24307 if (!args) SWIG_fail;
24308 swig_obj[0] = args;
24309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24312 }
24313 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24314 result = (bool) ((arg1)->m_rightDown);
24315 {
24316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24317 }
24318 return resultobj;
24319 fail:
24320 return NULL;
24321 }
24322
24323
24324 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24325 PyObject *resultobj = 0;
24326 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24327 bool arg2 ;
24328 void *argp1 = 0 ;
24329 int res1 = 0 ;
24330 bool val2 ;
24331 int ecode2 = 0 ;
24332 PyObject *swig_obj[2] ;
24333
24334 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24336 if (!SWIG_IsOK(res1)) {
24337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24338 }
24339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24340 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24341 if (!SWIG_IsOK(ecode2)) {
24342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24343 }
24344 arg2 = static_cast< bool >(val2);
24345 if (arg1) (arg1)->m_controlDown = arg2;
24346
24347 resultobj = SWIG_Py_Void();
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355 PyObject *resultobj = 0;
24356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24357 bool result;
24358 void *argp1 = 0 ;
24359 int res1 = 0 ;
24360 PyObject *swig_obj[1] ;
24361
24362 if (!args) SWIG_fail;
24363 swig_obj[0] = args;
24364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24365 if (!SWIG_IsOK(res1)) {
24366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24367 }
24368 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24369 result = (bool) ((arg1)->m_controlDown);
24370 {
24371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24372 }
24373 return resultobj;
24374 fail:
24375 return NULL;
24376 }
24377
24378
24379 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24380 PyObject *resultobj = 0;
24381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24382 bool arg2 ;
24383 void *argp1 = 0 ;
24384 int res1 = 0 ;
24385 bool val2 ;
24386 int ecode2 = 0 ;
24387 PyObject *swig_obj[2] ;
24388
24389 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24391 if (!SWIG_IsOK(res1)) {
24392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24393 }
24394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24395 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24396 if (!SWIG_IsOK(ecode2)) {
24397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24398 }
24399 arg2 = static_cast< bool >(val2);
24400 if (arg1) (arg1)->m_shiftDown = arg2;
24401
24402 resultobj = SWIG_Py_Void();
24403 return resultobj;
24404 fail:
24405 return NULL;
24406 }
24407
24408
24409 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24410 PyObject *resultobj = 0;
24411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24412 bool result;
24413 void *argp1 = 0 ;
24414 int res1 = 0 ;
24415 PyObject *swig_obj[1] ;
24416
24417 if (!args) SWIG_fail;
24418 swig_obj[0] = args;
24419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24420 if (!SWIG_IsOK(res1)) {
24421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24422 }
24423 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24424 result = (bool) ((arg1)->m_shiftDown);
24425 {
24426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24427 }
24428 return resultobj;
24429 fail:
24430 return NULL;
24431 }
24432
24433
24434 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24435 PyObject *resultobj = 0;
24436 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24437 bool arg2 ;
24438 void *argp1 = 0 ;
24439 int res1 = 0 ;
24440 bool val2 ;
24441 int ecode2 = 0 ;
24442 PyObject *swig_obj[2] ;
24443
24444 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24446 if (!SWIG_IsOK(res1)) {
24447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24448 }
24449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24450 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24451 if (!SWIG_IsOK(ecode2)) {
24452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24453 }
24454 arg2 = static_cast< bool >(val2);
24455 if (arg1) (arg1)->m_altDown = arg2;
24456
24457 resultobj = SWIG_Py_Void();
24458 return resultobj;
24459 fail:
24460 return NULL;
24461 }
24462
24463
24464 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24465 PyObject *resultobj = 0;
24466 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24467 bool result;
24468 void *argp1 = 0 ;
24469 int res1 = 0 ;
24470 PyObject *swig_obj[1] ;
24471
24472 if (!args) SWIG_fail;
24473 swig_obj[0] = args;
24474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24475 if (!SWIG_IsOK(res1)) {
24476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24477 }
24478 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24479 result = (bool) ((arg1)->m_altDown);
24480 {
24481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24482 }
24483 return resultobj;
24484 fail:
24485 return NULL;
24486 }
24487
24488
24489 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24490 PyObject *resultobj = 0;
24491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24492 bool arg2 ;
24493 void *argp1 = 0 ;
24494 int res1 = 0 ;
24495 bool val2 ;
24496 int ecode2 = 0 ;
24497 PyObject *swig_obj[2] ;
24498
24499 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24503 }
24504 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24505 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24508 }
24509 arg2 = static_cast< bool >(val2);
24510 if (arg1) (arg1)->m_metaDown = arg2;
24511
24512 resultobj = SWIG_Py_Void();
24513 return resultobj;
24514 fail:
24515 return NULL;
24516 }
24517
24518
24519 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24520 PyObject *resultobj = 0;
24521 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24522 bool result;
24523 void *argp1 = 0 ;
24524 int res1 = 0 ;
24525 PyObject *swig_obj[1] ;
24526
24527 if (!args) SWIG_fail;
24528 swig_obj[0] = args;
24529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24530 if (!SWIG_IsOK(res1)) {
24531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24532 }
24533 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24534 result = (bool) ((arg1)->m_metaDown);
24535 {
24536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24537 }
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24545 PyObject *resultobj = 0;
24546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24547 int arg2 ;
24548 void *argp1 = 0 ;
24549 int res1 = 0 ;
24550 int val2 ;
24551 int ecode2 = 0 ;
24552 PyObject *swig_obj[2] ;
24553
24554 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24556 if (!SWIG_IsOK(res1)) {
24557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24558 }
24559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24560 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24561 if (!SWIG_IsOK(ecode2)) {
24562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24563 }
24564 arg2 = static_cast< int >(val2);
24565 if (arg1) (arg1)->m_wheelRotation = arg2;
24566
24567 resultobj = SWIG_Py_Void();
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24575 PyObject *resultobj = 0;
24576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24577 int result;
24578 void *argp1 = 0 ;
24579 int res1 = 0 ;
24580 PyObject *swig_obj[1] ;
24581
24582 if (!args) SWIG_fail;
24583 swig_obj[0] = args;
24584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24585 if (!SWIG_IsOK(res1)) {
24586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24587 }
24588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24589 result = (int) ((arg1)->m_wheelRotation);
24590 resultobj = SWIG_From_int(static_cast< int >(result));
24591 return resultobj;
24592 fail:
24593 return NULL;
24594 }
24595
24596
24597 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 PyObject *resultobj = 0;
24599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24600 int arg2 ;
24601 void *argp1 = 0 ;
24602 int res1 = 0 ;
24603 int val2 ;
24604 int ecode2 = 0 ;
24605 PyObject *swig_obj[2] ;
24606
24607 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24611 }
24612 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24613 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24614 if (!SWIG_IsOK(ecode2)) {
24615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24616 }
24617 arg2 = static_cast< int >(val2);
24618 if (arg1) (arg1)->m_wheelDelta = arg2;
24619
24620 resultobj = SWIG_Py_Void();
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24628 PyObject *resultobj = 0;
24629 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24630 int result;
24631 void *argp1 = 0 ;
24632 int res1 = 0 ;
24633 PyObject *swig_obj[1] ;
24634
24635 if (!args) SWIG_fail;
24636 swig_obj[0] = args;
24637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24638 if (!SWIG_IsOK(res1)) {
24639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24640 }
24641 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24642 result = (int) ((arg1)->m_wheelDelta);
24643 resultobj = SWIG_From_int(static_cast< int >(result));
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24651 PyObject *resultobj = 0;
24652 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24653 int arg2 ;
24654 void *argp1 = 0 ;
24655 int res1 = 0 ;
24656 int val2 ;
24657 int ecode2 = 0 ;
24658 PyObject *swig_obj[2] ;
24659
24660 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24662 if (!SWIG_IsOK(res1)) {
24663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24664 }
24665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24667 if (!SWIG_IsOK(ecode2)) {
24668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24669 }
24670 arg2 = static_cast< int >(val2);
24671 if (arg1) (arg1)->m_linesPerAction = arg2;
24672
24673 resultobj = SWIG_Py_Void();
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 PyObject *resultobj = 0;
24682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24683 int result;
24684 void *argp1 = 0 ;
24685 int res1 = 0 ;
24686 PyObject *swig_obj[1] ;
24687
24688 if (!args) SWIG_fail;
24689 swig_obj[0] = args;
24690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24691 if (!SWIG_IsOK(res1)) {
24692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24693 }
24694 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24695 result = (int) ((arg1)->m_linesPerAction);
24696 resultobj = SWIG_From_int(static_cast< int >(result));
24697 return resultobj;
24698 fail:
24699 return NULL;
24700 }
24701
24702
24703 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24704 PyObject *obj;
24705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24706 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24707 return SWIG_Py_Void();
24708 }
24709
24710 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711 return SWIG_Python_InitShadowInstance(args);
24712 }
24713
24714 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24715 PyObject *resultobj = 0;
24716 int arg1 = (int) 0 ;
24717 int arg2 = (int) 0 ;
24718 wxSetCursorEvent *result = 0 ;
24719 int val1 ;
24720 int ecode1 = 0 ;
24721 int val2 ;
24722 int ecode2 = 0 ;
24723 PyObject * obj0 = 0 ;
24724 PyObject * obj1 = 0 ;
24725 char * kwnames[] = {
24726 (char *) "x",(char *) "y", NULL
24727 };
24728
24729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24730 if (obj0) {
24731 ecode1 = SWIG_AsVal_int(obj0, &val1);
24732 if (!SWIG_IsOK(ecode1)) {
24733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24734 }
24735 arg1 = static_cast< int >(val1);
24736 }
24737 if (obj1) {
24738 ecode2 = SWIG_AsVal_int(obj1, &val2);
24739 if (!SWIG_IsOK(ecode2)) {
24740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24741 }
24742 arg2 = static_cast< int >(val2);
24743 }
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24751 return resultobj;
24752 fail:
24753 return NULL;
24754 }
24755
24756
24757 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24758 PyObject *resultobj = 0;
24759 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24760 int result;
24761 void *argp1 = 0 ;
24762 int res1 = 0 ;
24763 PyObject *swig_obj[1] ;
24764
24765 if (!args) SWIG_fail;
24766 swig_obj[0] = args;
24767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24768 if (!SWIG_IsOK(res1)) {
24769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24770 }
24771 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24775 wxPyEndAllowThreads(__tstate);
24776 if (PyErr_Occurred()) SWIG_fail;
24777 }
24778 resultobj = SWIG_From_int(static_cast< int >(result));
24779 return resultobj;
24780 fail:
24781 return NULL;
24782 }
24783
24784
24785 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24786 PyObject *resultobj = 0;
24787 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24788 int result;
24789 void *argp1 = 0 ;
24790 int res1 = 0 ;
24791 PyObject *swig_obj[1] ;
24792
24793 if (!args) SWIG_fail;
24794 swig_obj[0] = args;
24795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24796 if (!SWIG_IsOK(res1)) {
24797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24798 }
24799 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24803 wxPyEndAllowThreads(__tstate);
24804 if (PyErr_Occurred()) SWIG_fail;
24805 }
24806 resultobj = SWIG_From_int(static_cast< int >(result));
24807 return resultobj;
24808 fail:
24809 return NULL;
24810 }
24811
24812
24813 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24814 PyObject *resultobj = 0;
24815 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24816 wxCursor *arg2 = 0 ;
24817 void *argp1 = 0 ;
24818 int res1 = 0 ;
24819 void *argp2 = 0 ;
24820 int res2 = 0 ;
24821 PyObject * obj0 = 0 ;
24822 PyObject * obj1 = 0 ;
24823 char * kwnames[] = {
24824 (char *) "self",(char *) "cursor", NULL
24825 };
24826
24827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24829 if (!SWIG_IsOK(res1)) {
24830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24831 }
24832 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24834 if (!SWIG_IsOK(res2)) {
24835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24836 }
24837 if (!argp2) {
24838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24839 }
24840 arg2 = reinterpret_cast< wxCursor * >(argp2);
24841 {
24842 PyThreadState* __tstate = wxPyBeginAllowThreads();
24843 (arg1)->SetCursor((wxCursor const &)*arg2);
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 resultobj = SWIG_Py_Void();
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24855 PyObject *resultobj = 0;
24856 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24857 wxCursor *result = 0 ;
24858 void *argp1 = 0 ;
24859 int res1 = 0 ;
24860 PyObject *swig_obj[1] ;
24861
24862 if (!args) SWIG_fail;
24863 swig_obj[0] = args;
24864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24865 if (!SWIG_IsOK(res1)) {
24866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24867 }
24868 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24869 {
24870 PyThreadState* __tstate = wxPyBeginAllowThreads();
24871 {
24872 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24873 result = (wxCursor *) &_result_ref;
24874 }
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 wxCursor* resultptr = new wxCursor(*result);
24880 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24881 }
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24889 PyObject *resultobj = 0;
24890 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24891 bool result;
24892 void *argp1 = 0 ;
24893 int res1 = 0 ;
24894 PyObject *swig_obj[1] ;
24895
24896 if (!args) SWIG_fail;
24897 swig_obj[0] = args;
24898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24899 if (!SWIG_IsOK(res1)) {
24900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24901 }
24902 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 {
24910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *obj;
24920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24921 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24922 return SWIG_Py_Void();
24923 }
24924
24925 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24926 return SWIG_Python_InitShadowInstance(args);
24927 }
24928
24929 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24930 PyObject *resultobj = 0;
24931 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24932 wxKeyEvent *result = 0 ;
24933 int val1 ;
24934 int ecode1 = 0 ;
24935 PyObject * obj0 = 0 ;
24936 char * kwnames[] = {
24937 (char *) "eventType", NULL
24938 };
24939
24940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24941 if (obj0) {
24942 ecode1 = SWIG_AsVal_int(obj0, &val1);
24943 if (!SWIG_IsOK(ecode1)) {
24944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24945 }
24946 arg1 = static_cast< wxEventType >(val1);
24947 }
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24962 PyObject *resultobj = 0;
24963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24964 int result;
24965 void *argp1 = 0 ;
24966 int res1 = 0 ;
24967 PyObject *swig_obj[1] ;
24968
24969 if (!args) SWIG_fail;
24970 swig_obj[0] = args;
24971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24972 if (!SWIG_IsOK(res1)) {
24973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24974 }
24975 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24979 wxPyEndAllowThreads(__tstate);
24980 if (PyErr_Occurred()) SWIG_fail;
24981 }
24982 resultobj = SWIG_From_int(static_cast< int >(result));
24983 return resultobj;
24984 fail:
24985 return NULL;
24986 }
24987
24988
24989 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24990 PyObject *resultobj = 0;
24991 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24992 bool result;
24993 void *argp1 = 0 ;
24994 int res1 = 0 ;
24995 PyObject *swig_obj[1] ;
24996
24997 if (!args) SWIG_fail;
24998 swig_obj[0] = args;
24999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25000 if (!SWIG_IsOK(res1)) {
25001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25002 }
25003 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25004 {
25005 PyThreadState* __tstate = wxPyBeginAllowThreads();
25006 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25007 wxPyEndAllowThreads(__tstate);
25008 if (PyErr_Occurred()) SWIG_fail;
25009 }
25010 {
25011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25012 }
25013 return resultobj;
25014 fail:
25015 return NULL;
25016 }
25017
25018
25019 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25020 PyObject *resultobj = 0;
25021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25022 bool result;
25023 void *argp1 = 0 ;
25024 int res1 = 0 ;
25025 PyObject *swig_obj[1] ;
25026
25027 if (!args) SWIG_fail;
25028 swig_obj[0] = args;
25029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25030 if (!SWIG_IsOK(res1)) {
25031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25032 }
25033 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 {
25041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25042 }
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25050 PyObject *resultobj = 0;
25051 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25052 bool result;
25053 void *argp1 = 0 ;
25054 int res1 = 0 ;
25055 PyObject *swig_obj[1] ;
25056
25057 if (!args) SWIG_fail;
25058 swig_obj[0] = args;
25059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25060 if (!SWIG_IsOK(res1)) {
25061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25062 }
25063 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25064 {
25065 PyThreadState* __tstate = wxPyBeginAllowThreads();
25066 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25067 wxPyEndAllowThreads(__tstate);
25068 if (PyErr_Occurred()) SWIG_fail;
25069 }
25070 {
25071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25072 }
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25080 PyObject *resultobj = 0;
25081 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25082 bool result;
25083 void *argp1 = 0 ;
25084 int res1 = 0 ;
25085 PyObject *swig_obj[1] ;
25086
25087 if (!args) SWIG_fail;
25088 swig_obj[0] = args;
25089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25090 if (!SWIG_IsOK(res1)) {
25091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25092 }
25093 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25094 {
25095 PyThreadState* __tstate = wxPyBeginAllowThreads();
25096 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25102 }
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25110 PyObject *resultobj = 0;
25111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25112 bool result;
25113 void *argp1 = 0 ;
25114 int res1 = 0 ;
25115 PyObject *swig_obj[1] ;
25116
25117 if (!args) SWIG_fail;
25118 swig_obj[0] = args;
25119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25120 if (!SWIG_IsOK(res1)) {
25121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25122 }
25123 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25127 wxPyEndAllowThreads(__tstate);
25128 if (PyErr_Occurred()) SWIG_fail;
25129 }
25130 {
25131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25132 }
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25140 PyObject *resultobj = 0;
25141 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25142 bool result;
25143 void *argp1 = 0 ;
25144 int res1 = 0 ;
25145 PyObject *swig_obj[1] ;
25146
25147 if (!args) SWIG_fail;
25148 swig_obj[0] = args;
25149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25150 if (!SWIG_IsOK(res1)) {
25151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25152 }
25153 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 {
25161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25162 }
25163 return resultobj;
25164 fail:
25165 return NULL;
25166 }
25167
25168
25169 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25170 PyObject *resultobj = 0;
25171 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25172 int result;
25173 void *argp1 = 0 ;
25174 int res1 = 0 ;
25175 PyObject *swig_obj[1] ;
25176
25177 if (!args) SWIG_fail;
25178 swig_obj[0] = args;
25179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25180 if (!SWIG_IsOK(res1)) {
25181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25182 }
25183 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25187 wxPyEndAllowThreads(__tstate);
25188 if (PyErr_Occurred()) SWIG_fail;
25189 }
25190 resultobj = SWIG_From_int(static_cast< int >(result));
25191 return resultobj;
25192 fail:
25193 return NULL;
25194 }
25195
25196
25197 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25198 PyObject *resultobj = 0;
25199 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25200 int result;
25201 void *argp1 = 0 ;
25202 int res1 = 0 ;
25203 PyObject *swig_obj[1] ;
25204
25205 if (!args) SWIG_fail;
25206 swig_obj[0] = args;
25207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25208 if (!SWIG_IsOK(res1)) {
25209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25210 }
25211 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 resultobj = SWIG_From_int(static_cast< int >(result));
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25226 PyObject *resultobj = 0;
25227 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25228 int arg2 ;
25229 void *argp1 = 0 ;
25230 int res1 = 0 ;
25231 int val2 ;
25232 int ecode2 = 0 ;
25233 PyObject * obj0 = 0 ;
25234 PyObject * obj1 = 0 ;
25235 char * kwnames[] = {
25236 (char *) "self",(char *) "uniChar", NULL
25237 };
25238
25239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25241 if (!SWIG_IsOK(res1)) {
25242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25243 }
25244 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25245 ecode2 = SWIG_AsVal_int(obj1, &val2);
25246 if (!SWIG_IsOK(ecode2)) {
25247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25248 }
25249 arg2 = static_cast< int >(val2);
25250 {
25251 PyThreadState* __tstate = wxPyBeginAllowThreads();
25252 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25253 wxPyEndAllowThreads(__tstate);
25254 if (PyErr_Occurred()) SWIG_fail;
25255 }
25256 resultobj = SWIG_Py_Void();
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25264 PyObject *resultobj = 0;
25265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25266 unsigned int result;
25267 void *argp1 = 0 ;
25268 int res1 = 0 ;
25269 PyObject *swig_obj[1] ;
25270
25271 if (!args) SWIG_fail;
25272 swig_obj[0] = args;
25273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25274 if (!SWIG_IsOK(res1)) {
25275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25276 }
25277 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 PyObject *resultobj = 0;
25293 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25294 unsigned int result;
25295 void *argp1 = 0 ;
25296 int res1 = 0 ;
25297 PyObject *swig_obj[1] ;
25298
25299 if (!args) SWIG_fail;
25300 swig_obj[0] = args;
25301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25304 }
25305 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25309 wxPyEndAllowThreads(__tstate);
25310 if (PyErr_Occurred()) SWIG_fail;
25311 }
25312 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25313 return resultobj;
25314 fail:
25315 return NULL;
25316 }
25317
25318
25319 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25320 PyObject *resultobj = 0;
25321 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25322 wxPoint result;
25323 void *argp1 = 0 ;
25324 int res1 = 0 ;
25325 PyObject *swig_obj[1] ;
25326
25327 if (!args) SWIG_fail;
25328 swig_obj[0] = args;
25329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25330 if (!SWIG_IsOK(res1)) {
25331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25332 }
25333 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25334 {
25335 PyThreadState* __tstate = wxPyBeginAllowThreads();
25336 result = (arg1)->GetPosition();
25337 wxPyEndAllowThreads(__tstate);
25338 if (PyErr_Occurred()) SWIG_fail;
25339 }
25340 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25341 return resultobj;
25342 fail:
25343 return NULL;
25344 }
25345
25346
25347 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25348 PyObject *resultobj = 0;
25349 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25350 long *arg2 = (long *) 0 ;
25351 long *arg3 = (long *) 0 ;
25352 void *argp1 = 0 ;
25353 int res1 = 0 ;
25354 long temp2 ;
25355 int res2 = SWIG_TMPOBJ ;
25356 long temp3 ;
25357 int res3 = SWIG_TMPOBJ ;
25358 PyObject *swig_obj[1] ;
25359
25360 arg2 = &temp2;
25361 arg3 = &temp3;
25362 if (!args) SWIG_fail;
25363 swig_obj[0] = args;
25364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25365 if (!SWIG_IsOK(res1)) {
25366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25367 }
25368 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 (arg1)->GetPosition(arg2,arg3);
25372 wxPyEndAllowThreads(__tstate);
25373 if (PyErr_Occurred()) SWIG_fail;
25374 }
25375 resultobj = SWIG_Py_Void();
25376 if (SWIG_IsTmpObj(res2)) {
25377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25378 } else {
25379 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25381 }
25382 if (SWIG_IsTmpObj(res3)) {
25383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25384 } else {
25385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25387 }
25388 return resultobj;
25389 fail:
25390 return NULL;
25391 }
25392
25393
25394 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25395 PyObject *resultobj = 0;
25396 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25397 int result;
25398 void *argp1 = 0 ;
25399 int res1 = 0 ;
25400 PyObject *swig_obj[1] ;
25401
25402 if (!args) SWIG_fail;
25403 swig_obj[0] = args;
25404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25405 if (!SWIG_IsOK(res1)) {
25406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25407 }
25408 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25409 {
25410 PyThreadState* __tstate = wxPyBeginAllowThreads();
25411 result = (int)((wxKeyEvent const *)arg1)->GetX();
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 resultobj = SWIG_From_int(static_cast< int >(result));
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *resultobj = 0;
25424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25425 int result;
25426 void *argp1 = 0 ;
25427 int res1 = 0 ;
25428 PyObject *swig_obj[1] ;
25429
25430 if (!args) SWIG_fail;
25431 swig_obj[0] = args;
25432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25433 if (!SWIG_IsOK(res1)) {
25434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25435 }
25436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25437 {
25438 PyThreadState* __tstate = wxPyBeginAllowThreads();
25439 result = (int)((wxKeyEvent const *)arg1)->GetY();
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 resultobj = SWIG_From_int(static_cast< int >(result));
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25451 PyObject *resultobj = 0;
25452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25453 int arg2 ;
25454 void *argp1 = 0 ;
25455 int res1 = 0 ;
25456 int val2 ;
25457 int ecode2 = 0 ;
25458 PyObject *swig_obj[2] ;
25459
25460 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25462 if (!SWIG_IsOK(res1)) {
25463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25464 }
25465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25466 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25467 if (!SWIG_IsOK(ecode2)) {
25468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25469 }
25470 arg2 = static_cast< int >(val2);
25471 if (arg1) (arg1)->m_x = arg2;
25472
25473 resultobj = SWIG_Py_Void();
25474 return resultobj;
25475 fail:
25476 return NULL;
25477 }
25478
25479
25480 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25481 PyObject *resultobj = 0;
25482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25483 int result;
25484 void *argp1 = 0 ;
25485 int res1 = 0 ;
25486 PyObject *swig_obj[1] ;
25487
25488 if (!args) SWIG_fail;
25489 swig_obj[0] = args;
25490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25491 if (!SWIG_IsOK(res1)) {
25492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25493 }
25494 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25495 result = (int) ((arg1)->m_x);
25496 resultobj = SWIG_From_int(static_cast< int >(result));
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25504 PyObject *resultobj = 0;
25505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25506 int arg2 ;
25507 void *argp1 = 0 ;
25508 int res1 = 0 ;
25509 int val2 ;
25510 int ecode2 = 0 ;
25511 PyObject *swig_obj[2] ;
25512
25513 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25515 if (!SWIG_IsOK(res1)) {
25516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25517 }
25518 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25519 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25520 if (!SWIG_IsOK(ecode2)) {
25521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25522 }
25523 arg2 = static_cast< int >(val2);
25524 if (arg1) (arg1)->m_y = arg2;
25525
25526 resultobj = SWIG_Py_Void();
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25534 PyObject *resultobj = 0;
25535 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25536 int result;
25537 void *argp1 = 0 ;
25538 int res1 = 0 ;
25539 PyObject *swig_obj[1] ;
25540
25541 if (!args) SWIG_fail;
25542 swig_obj[0] = args;
25543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25544 if (!SWIG_IsOK(res1)) {
25545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25546 }
25547 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25548 result = (int) ((arg1)->m_y);
25549 resultobj = SWIG_From_int(static_cast< int >(result));
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 PyObject *resultobj = 0;
25558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25559 long arg2 ;
25560 void *argp1 = 0 ;
25561 int res1 = 0 ;
25562 long val2 ;
25563 int ecode2 = 0 ;
25564 PyObject *swig_obj[2] ;
25565
25566 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25568 if (!SWIG_IsOK(res1)) {
25569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25570 }
25571 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25572 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25573 if (!SWIG_IsOK(ecode2)) {
25574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25575 }
25576 arg2 = static_cast< long >(val2);
25577 if (arg1) (arg1)->m_keyCode = arg2;
25578
25579 resultobj = SWIG_Py_Void();
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25589 long result;
25590 void *argp1 = 0 ;
25591 int res1 = 0 ;
25592 PyObject *swig_obj[1] ;
25593
25594 if (!args) SWIG_fail;
25595 swig_obj[0] = args;
25596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25597 if (!SWIG_IsOK(res1)) {
25598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25599 }
25600 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25601 result = (long) ((arg1)->m_keyCode);
25602 resultobj = SWIG_From_long(static_cast< long >(result));
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25610 PyObject *resultobj = 0;
25611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25612 bool arg2 ;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 bool val2 ;
25616 int ecode2 = 0 ;
25617 PyObject *swig_obj[2] ;
25618
25619 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25621 if (!SWIG_IsOK(res1)) {
25622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25623 }
25624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25625 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25626 if (!SWIG_IsOK(ecode2)) {
25627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25628 }
25629 arg2 = static_cast< bool >(val2);
25630 if (arg1) (arg1)->m_controlDown = arg2;
25631
25632 resultobj = SWIG_Py_Void();
25633 return resultobj;
25634 fail:
25635 return NULL;
25636 }
25637
25638
25639 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25640 PyObject *resultobj = 0;
25641 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25642 bool result;
25643 void *argp1 = 0 ;
25644 int res1 = 0 ;
25645 PyObject *swig_obj[1] ;
25646
25647 if (!args) SWIG_fail;
25648 swig_obj[0] = args;
25649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25650 if (!SWIG_IsOK(res1)) {
25651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25652 }
25653 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25654 result = (bool) ((arg1)->m_controlDown);
25655 {
25656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25657 }
25658 return resultobj;
25659 fail:
25660 return NULL;
25661 }
25662
25663
25664 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 PyObject *resultobj = 0;
25666 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25667 bool arg2 ;
25668 void *argp1 = 0 ;
25669 int res1 = 0 ;
25670 bool val2 ;
25671 int ecode2 = 0 ;
25672 PyObject *swig_obj[2] ;
25673
25674 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25678 }
25679 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25680 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25681 if (!SWIG_IsOK(ecode2)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25683 }
25684 arg2 = static_cast< bool >(val2);
25685 if (arg1) (arg1)->m_shiftDown = arg2;
25686
25687 resultobj = SWIG_Py_Void();
25688 return resultobj;
25689 fail:
25690 return NULL;
25691 }
25692
25693
25694 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25695 PyObject *resultobj = 0;
25696 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25697 bool result;
25698 void *argp1 = 0 ;
25699 int res1 = 0 ;
25700 PyObject *swig_obj[1] ;
25701
25702 if (!args) SWIG_fail;
25703 swig_obj[0] = args;
25704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25705 if (!SWIG_IsOK(res1)) {
25706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25707 }
25708 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25709 result = (bool) ((arg1)->m_shiftDown);
25710 {
25711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25712 }
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25720 PyObject *resultobj = 0;
25721 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25722 bool arg2 ;
25723 void *argp1 = 0 ;
25724 int res1 = 0 ;
25725 bool val2 ;
25726 int ecode2 = 0 ;
25727 PyObject *swig_obj[2] ;
25728
25729 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25731 if (!SWIG_IsOK(res1)) {
25732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25733 }
25734 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25735 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25736 if (!SWIG_IsOK(ecode2)) {
25737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25738 }
25739 arg2 = static_cast< bool >(val2);
25740 if (arg1) (arg1)->m_altDown = arg2;
25741
25742 resultobj = SWIG_Py_Void();
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25750 PyObject *resultobj = 0;
25751 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25752 bool result;
25753 void *argp1 = 0 ;
25754 int res1 = 0 ;
25755 PyObject *swig_obj[1] ;
25756
25757 if (!args) SWIG_fail;
25758 swig_obj[0] = args;
25759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25760 if (!SWIG_IsOK(res1)) {
25761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25762 }
25763 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25764 result = (bool) ((arg1)->m_altDown);
25765 {
25766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25767 }
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25775 PyObject *resultobj = 0;
25776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25777 bool arg2 ;
25778 void *argp1 = 0 ;
25779 int res1 = 0 ;
25780 bool val2 ;
25781 int ecode2 = 0 ;
25782 PyObject *swig_obj[2] ;
25783
25784 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25788 }
25789 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25790 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25791 if (!SWIG_IsOK(ecode2)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25793 }
25794 arg2 = static_cast< bool >(val2);
25795 if (arg1) (arg1)->m_metaDown = arg2;
25796
25797 resultobj = SWIG_Py_Void();
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25805 PyObject *resultobj = 0;
25806 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25807 bool result;
25808 void *argp1 = 0 ;
25809 int res1 = 0 ;
25810 PyObject *swig_obj[1] ;
25811
25812 if (!args) SWIG_fail;
25813 swig_obj[0] = args;
25814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25815 if (!SWIG_IsOK(res1)) {
25816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25817 }
25818 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25819 result = (bool) ((arg1)->m_metaDown);
25820 {
25821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25830 PyObject *resultobj = 0;
25831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25832 bool arg2 ;
25833 void *argp1 = 0 ;
25834 int res1 = 0 ;
25835 bool val2 ;
25836 int ecode2 = 0 ;
25837 PyObject *swig_obj[2] ;
25838
25839 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25841 if (!SWIG_IsOK(res1)) {
25842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25843 }
25844 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25845 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25846 if (!SWIG_IsOK(ecode2)) {
25847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25848 }
25849 arg2 = static_cast< bool >(val2);
25850 if (arg1) (arg1)->m_scanCode = arg2;
25851
25852 resultobj = SWIG_Py_Void();
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25860 PyObject *resultobj = 0;
25861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25862 bool result;
25863 void *argp1 = 0 ;
25864 int res1 = 0 ;
25865 PyObject *swig_obj[1] ;
25866
25867 if (!args) SWIG_fail;
25868 swig_obj[0] = args;
25869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25870 if (!SWIG_IsOK(res1)) {
25871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25872 }
25873 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25874 result = (bool) ((arg1)->m_scanCode);
25875 {
25876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25877 }
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 PyObject *resultobj = 0;
25886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25887 unsigned int arg2 ;
25888 void *argp1 = 0 ;
25889 int res1 = 0 ;
25890 unsigned int val2 ;
25891 int ecode2 = 0 ;
25892 PyObject *swig_obj[2] ;
25893
25894 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25896 if (!SWIG_IsOK(res1)) {
25897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25898 }
25899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25900 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25901 if (!SWIG_IsOK(ecode2)) {
25902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25903 }
25904 arg2 = static_cast< unsigned int >(val2);
25905 if (arg1) (arg1)->m_rawCode = arg2;
25906
25907 resultobj = SWIG_Py_Void();
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 PyObject *resultobj = 0;
25916 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25917 unsigned int result;
25918 void *argp1 = 0 ;
25919 int res1 = 0 ;
25920 PyObject *swig_obj[1] ;
25921
25922 if (!args) SWIG_fail;
25923 swig_obj[0] = args;
25924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25925 if (!SWIG_IsOK(res1)) {
25926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25927 }
25928 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25929 result = (unsigned int) ((arg1)->m_rawCode);
25930 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25931 return resultobj;
25932 fail:
25933 return NULL;
25934 }
25935
25936
25937 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25938 PyObject *resultobj = 0;
25939 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25940 unsigned int arg2 ;
25941 void *argp1 = 0 ;
25942 int res1 = 0 ;
25943 unsigned int val2 ;
25944 int ecode2 = 0 ;
25945 PyObject *swig_obj[2] ;
25946
25947 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25949 if (!SWIG_IsOK(res1)) {
25950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25951 }
25952 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25953 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25954 if (!SWIG_IsOK(ecode2)) {
25955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25956 }
25957 arg2 = static_cast< unsigned int >(val2);
25958 if (arg1) (arg1)->m_rawFlags = arg2;
25959
25960 resultobj = SWIG_Py_Void();
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25968 PyObject *resultobj = 0;
25969 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25970 unsigned int result;
25971 void *argp1 = 0 ;
25972 int res1 = 0 ;
25973 PyObject *swig_obj[1] ;
25974
25975 if (!args) SWIG_fail;
25976 swig_obj[0] = args;
25977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25978 if (!SWIG_IsOK(res1)) {
25979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25980 }
25981 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25982 result = (unsigned int) ((arg1)->m_rawFlags);
25983 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25984 return resultobj;
25985 fail:
25986 return NULL;
25987 }
25988
25989
25990 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25991 PyObject *obj;
25992 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25993 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25994 return SWIG_Py_Void();
25995 }
25996
25997 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 return SWIG_Python_InitShadowInstance(args);
25999 }
26000
26001 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxSize const &arg1_defvalue = wxDefaultSize ;
26004 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26005 int arg2 = (int) 0 ;
26006 wxSizeEvent *result = 0 ;
26007 wxSize temp1 ;
26008 int val2 ;
26009 int ecode2 = 0 ;
26010 PyObject * obj0 = 0 ;
26011 PyObject * obj1 = 0 ;
26012 char * kwnames[] = {
26013 (char *) "sz",(char *) "winid", NULL
26014 };
26015
26016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26017 if (obj0) {
26018 {
26019 arg1 = &temp1;
26020 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26021 }
26022 }
26023 if (obj1) {
26024 ecode2 = SWIG_AsVal_int(obj1, &val2);
26025 if (!SWIG_IsOK(ecode2)) {
26026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26027 }
26028 arg2 = static_cast< int >(val2);
26029 }
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26033 wxPyEndAllowThreads(__tstate);
26034 if (PyErr_Occurred()) SWIG_fail;
26035 }
26036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26044 PyObject *resultobj = 0;
26045 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26046 wxSize result;
26047 void *argp1 = 0 ;
26048 int res1 = 0 ;
26049 PyObject *swig_obj[1] ;
26050
26051 if (!args) SWIG_fail;
26052 swig_obj[0] = args;
26053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26054 if (!SWIG_IsOK(res1)) {
26055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26056 }
26057 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26058 {
26059 PyThreadState* __tstate = wxPyBeginAllowThreads();
26060 result = ((wxSizeEvent const *)arg1)->GetSize();
26061 wxPyEndAllowThreads(__tstate);
26062 if (PyErr_Occurred()) SWIG_fail;
26063 }
26064 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26065 return resultobj;
26066 fail:
26067 return NULL;
26068 }
26069
26070
26071 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26072 PyObject *resultobj = 0;
26073 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26074 wxRect result;
26075 void *argp1 = 0 ;
26076 int res1 = 0 ;
26077 PyObject *swig_obj[1] ;
26078
26079 if (!args) SWIG_fail;
26080 swig_obj[0] = args;
26081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26082 if (!SWIG_IsOK(res1)) {
26083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26084 }
26085 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = ((wxSizeEvent const *)arg1)->GetRect();
26089 wxPyEndAllowThreads(__tstate);
26090 if (PyErr_Occurred()) SWIG_fail;
26091 }
26092 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26093 return resultobj;
26094 fail:
26095 return NULL;
26096 }
26097
26098
26099 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26100 PyObject *resultobj = 0;
26101 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26102 wxRect arg2 ;
26103 void *argp1 = 0 ;
26104 int res1 = 0 ;
26105 void *argp2 ;
26106 int res2 = 0 ;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char * kwnames[] = {
26110 (char *) "self",(char *) "rect", NULL
26111 };
26112
26113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26115 if (!SWIG_IsOK(res1)) {
26116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26117 }
26118 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26119 {
26120 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26121 if (!SWIG_IsOK(res2)) {
26122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26123 }
26124 if (!argp2) {
26125 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26126 } else {
26127 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26128 arg2 = *temp;
26129 if (SWIG_IsNewObj(res2)) delete temp;
26130 }
26131 }
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 (arg1)->SetRect(arg2);
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_Py_Void();
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26146 PyObject *resultobj = 0;
26147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26148 wxSize arg2 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 void *argp2 ;
26152 int res2 = 0 ;
26153 PyObject * obj0 = 0 ;
26154 PyObject * obj1 = 0 ;
26155 char * kwnames[] = {
26156 (char *) "self",(char *) "size", NULL
26157 };
26158
26159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26163 }
26164 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26165 {
26166 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26167 if (!SWIG_IsOK(res2)) {
26168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26169 }
26170 if (!argp2) {
26171 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26172 } else {
26173 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26174 arg2 = *temp;
26175 if (SWIG_IsNewObj(res2)) delete temp;
26176 }
26177 }
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 wxSizeEvent_SetSize(arg1,arg2);
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_Py_Void();
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 PyObject *resultobj = 0;
26193 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26194 wxSize *arg2 = (wxSize *) 0 ;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 void *argp2 = 0 ;
26198 int res2 = 0 ;
26199 PyObject *swig_obj[2] ;
26200
26201 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26203 if (!SWIG_IsOK(res1)) {
26204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26205 }
26206 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26207 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26208 if (!SWIG_IsOK(res2)) {
26209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26210 }
26211 arg2 = reinterpret_cast< wxSize * >(argp2);
26212 if (arg1) (arg1)->m_size = *arg2;
26213
26214 resultobj = SWIG_Py_Void();
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26222 PyObject *resultobj = 0;
26223 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26224 wxSize *result = 0 ;
26225 void *argp1 = 0 ;
26226 int res1 = 0 ;
26227 PyObject *swig_obj[1] ;
26228
26229 if (!args) SWIG_fail;
26230 swig_obj[0] = args;
26231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26232 if (!SWIG_IsOK(res1)) {
26233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26234 }
26235 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26236 result = (wxSize *)& ((arg1)->m_size);
26237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26238 return resultobj;
26239 fail:
26240 return NULL;
26241 }
26242
26243
26244 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26245 PyObject *resultobj = 0;
26246 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26247 wxRect *arg2 = (wxRect *) 0 ;
26248 void *argp1 = 0 ;
26249 int res1 = 0 ;
26250 void *argp2 = 0 ;
26251 int res2 = 0 ;
26252 PyObject *swig_obj[2] ;
26253
26254 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26256 if (!SWIG_IsOK(res1)) {
26257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26258 }
26259 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26260 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26261 if (!SWIG_IsOK(res2)) {
26262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26263 }
26264 arg2 = reinterpret_cast< wxRect * >(argp2);
26265 if (arg1) (arg1)->m_rect = *arg2;
26266
26267 resultobj = SWIG_Py_Void();
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 PyObject *resultobj = 0;
26276 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26277 wxRect *result = 0 ;
26278 void *argp1 = 0 ;
26279 int res1 = 0 ;
26280 PyObject *swig_obj[1] ;
26281
26282 if (!args) SWIG_fail;
26283 swig_obj[0] = args;
26284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26285 if (!SWIG_IsOK(res1)) {
26286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26287 }
26288 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26289 result = (wxRect *)& ((arg1)->m_rect);
26290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26298 PyObject *obj;
26299 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26300 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26301 return SWIG_Py_Void();
26302 }
26303
26304 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 return SWIG_Python_InitShadowInstance(args);
26306 }
26307
26308 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26309 PyObject *resultobj = 0;
26310 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26311 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26312 int arg2 = (int) 0 ;
26313 wxMoveEvent *result = 0 ;
26314 wxPoint temp1 ;
26315 int val2 ;
26316 int ecode2 = 0 ;
26317 PyObject * obj0 = 0 ;
26318 PyObject * obj1 = 0 ;
26319 char * kwnames[] = {
26320 (char *) "pos",(char *) "winid", NULL
26321 };
26322
26323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26324 if (obj0) {
26325 {
26326 arg1 = &temp1;
26327 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26328 }
26329 }
26330 if (obj1) {
26331 ecode2 = SWIG_AsVal_int(obj1, &val2);
26332 if (!SWIG_IsOK(ecode2)) {
26333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26334 }
26335 arg2 = static_cast< int >(val2);
26336 }
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26344 return resultobj;
26345 fail:
26346 return NULL;
26347 }
26348
26349
26350 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26351 PyObject *resultobj = 0;
26352 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26353 wxPoint result;
26354 void *argp1 = 0 ;
26355 int res1 = 0 ;
26356 PyObject *swig_obj[1] ;
26357
26358 if (!args) SWIG_fail;
26359 swig_obj[0] = args;
26360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26361 if (!SWIG_IsOK(res1)) {
26362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26363 }
26364 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26365 {
26366 PyThreadState* __tstate = wxPyBeginAllowThreads();
26367 result = ((wxMoveEvent const *)arg1)->GetPosition();
26368 wxPyEndAllowThreads(__tstate);
26369 if (PyErr_Occurred()) SWIG_fail;
26370 }
26371 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26379 PyObject *resultobj = 0;
26380 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26381 wxRect result;
26382 void *argp1 = 0 ;
26383 int res1 = 0 ;
26384 PyObject *swig_obj[1] ;
26385
26386 if (!args) SWIG_fail;
26387 swig_obj[0] = args;
26388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26389 if (!SWIG_IsOK(res1)) {
26390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26391 }
26392 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = ((wxMoveEvent const *)arg1)->GetRect();
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26407 PyObject *resultobj = 0;
26408 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26409 wxRect *arg2 = 0 ;
26410 void *argp1 = 0 ;
26411 int res1 = 0 ;
26412 wxRect temp2 ;
26413 PyObject * obj0 = 0 ;
26414 PyObject * obj1 = 0 ;
26415 char * kwnames[] = {
26416 (char *) "self",(char *) "rect", NULL
26417 };
26418
26419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26421 if (!SWIG_IsOK(res1)) {
26422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26423 }
26424 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26425 {
26426 arg2 = &temp2;
26427 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26428 }
26429 {
26430 PyThreadState* __tstate = wxPyBeginAllowThreads();
26431 (arg1)->SetRect((wxRect const &)*arg2);
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 resultobj = SWIG_Py_Void();
26436 return resultobj;
26437 fail:
26438 return NULL;
26439 }
26440
26441
26442 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26443 PyObject *resultobj = 0;
26444 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26445 wxPoint *arg2 = 0 ;
26446 void *argp1 = 0 ;
26447 int res1 = 0 ;
26448 wxPoint temp2 ;
26449 PyObject * obj0 = 0 ;
26450 PyObject * obj1 = 0 ;
26451 char * kwnames[] = {
26452 (char *) "self",(char *) "pos", NULL
26453 };
26454
26455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26457 if (!SWIG_IsOK(res1)) {
26458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26459 }
26460 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26461 {
26462 arg2 = &temp2;
26463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26464 }
26465 {
26466 PyThreadState* __tstate = wxPyBeginAllowThreads();
26467 (arg1)->SetPosition((wxPoint const &)*arg2);
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 resultobj = SWIG_Py_Void();
26472 return resultobj;
26473 fail:
26474 return NULL;
26475 }
26476
26477
26478 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479 PyObject *obj;
26480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26481 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26482 return SWIG_Py_Void();
26483 }
26484
26485 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26486 return SWIG_Python_InitShadowInstance(args);
26487 }
26488
26489 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26490 PyObject *resultobj = 0;
26491 int arg1 = (int) 0 ;
26492 wxPaintEvent *result = 0 ;
26493 int val1 ;
26494 int ecode1 = 0 ;
26495 PyObject * obj0 = 0 ;
26496 char * kwnames[] = {
26497 (char *) "Id", NULL
26498 };
26499
26500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26501 if (obj0) {
26502 ecode1 = SWIG_AsVal_int(obj0, &val1);
26503 if (!SWIG_IsOK(ecode1)) {
26504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26505 }
26506 arg1 = static_cast< int >(val1);
26507 }
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26515 return resultobj;
26516 fail:
26517 return NULL;
26518 }
26519
26520
26521 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26522 PyObject *obj;
26523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26524 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26525 return SWIG_Py_Void();
26526 }
26527
26528 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26529 return SWIG_Python_InitShadowInstance(args);
26530 }
26531
26532 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26533 PyObject *resultobj = 0;
26534 int arg1 = (int) 0 ;
26535 wxNcPaintEvent *result = 0 ;
26536 int val1 ;
26537 int ecode1 = 0 ;
26538 PyObject * obj0 = 0 ;
26539 char * kwnames[] = {
26540 (char *) "winid", NULL
26541 };
26542
26543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26544 if (obj0) {
26545 ecode1 = SWIG_AsVal_int(obj0, &val1);
26546 if (!SWIG_IsOK(ecode1)) {
26547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26548 }
26549 arg1 = static_cast< int >(val1);
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26554 wxPyEndAllowThreads(__tstate);
26555 if (PyErr_Occurred()) SWIG_fail;
26556 }
26557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26558 return resultobj;
26559 fail:
26560 return NULL;
26561 }
26562
26563
26564 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26565 PyObject *obj;
26566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26567 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26568 return SWIG_Py_Void();
26569 }
26570
26571 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26572 return SWIG_Python_InitShadowInstance(args);
26573 }
26574
26575 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj = 0;
26577 int arg1 = (int) 0 ;
26578 wxDC *arg2 = (wxDC *) NULL ;
26579 wxEraseEvent *result = 0 ;
26580 int val1 ;
26581 int ecode1 = 0 ;
26582 void *argp2 = 0 ;
26583 int res2 = 0 ;
26584 PyObject * obj0 = 0 ;
26585 PyObject * obj1 = 0 ;
26586 char * kwnames[] = {
26587 (char *) "Id",(char *) "dc", NULL
26588 };
26589
26590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26591 if (obj0) {
26592 ecode1 = SWIG_AsVal_int(obj0, &val1);
26593 if (!SWIG_IsOK(ecode1)) {
26594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26595 }
26596 arg1 = static_cast< int >(val1);
26597 }
26598 if (obj1) {
26599 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26600 if (!SWIG_IsOK(res2)) {
26601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26602 }
26603 arg2 = reinterpret_cast< wxDC * >(argp2);
26604 }
26605 {
26606 PyThreadState* __tstate = wxPyBeginAllowThreads();
26607 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26608 wxPyEndAllowThreads(__tstate);
26609 if (PyErr_Occurred()) SWIG_fail;
26610 }
26611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26612 return resultobj;
26613 fail:
26614 return NULL;
26615 }
26616
26617
26618 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26619 PyObject *resultobj = 0;
26620 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26621 wxDC *result = 0 ;
26622 void *argp1 = 0 ;
26623 int res1 = 0 ;
26624 PyObject *swig_obj[1] ;
26625
26626 if (!args) SWIG_fail;
26627 swig_obj[0] = args;
26628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26629 if (!SWIG_IsOK(res1)) {
26630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26631 }
26632 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26636 wxPyEndAllowThreads(__tstate);
26637 if (PyErr_Occurred()) SWIG_fail;
26638 }
26639 {
26640 resultobj = wxPyMake_wxObject(result, (bool)0);
26641 }
26642 return resultobj;
26643 fail:
26644 return NULL;
26645 }
26646
26647
26648 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26649 PyObject *obj;
26650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26651 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26652 return SWIG_Py_Void();
26653 }
26654
26655 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 return SWIG_Python_InitShadowInstance(args);
26657 }
26658
26659 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj = 0;
26661 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26662 int arg2 = (int) 0 ;
26663 wxFocusEvent *result = 0 ;
26664 int val1 ;
26665 int ecode1 = 0 ;
26666 int val2 ;
26667 int ecode2 = 0 ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "type",(char *) "winid", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26675 if (obj0) {
26676 ecode1 = SWIG_AsVal_int(obj0, &val1);
26677 if (!SWIG_IsOK(ecode1)) {
26678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26679 }
26680 arg1 = static_cast< wxEventType >(val1);
26681 }
26682 if (obj1) {
26683 ecode2 = SWIG_AsVal_int(obj1, &val2);
26684 if (!SWIG_IsOK(ecode2)) {
26685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26686 }
26687 arg2 = static_cast< int >(val2);
26688 }
26689 {
26690 PyThreadState* __tstate = wxPyBeginAllowThreads();
26691 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26692 wxPyEndAllowThreads(__tstate);
26693 if (PyErr_Occurred()) SWIG_fail;
26694 }
26695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26696 return resultobj;
26697 fail:
26698 return NULL;
26699 }
26700
26701
26702 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26703 PyObject *resultobj = 0;
26704 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26705 wxWindow *result = 0 ;
26706 void *argp1 = 0 ;
26707 int res1 = 0 ;
26708 PyObject *swig_obj[1] ;
26709
26710 if (!args) SWIG_fail;
26711 swig_obj[0] = args;
26712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26713 if (!SWIG_IsOK(res1)) {
26714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26715 }
26716 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26720 wxPyEndAllowThreads(__tstate);
26721 if (PyErr_Occurred()) SWIG_fail;
26722 }
26723 {
26724 resultobj = wxPyMake_wxObject(result, (bool)0);
26725 }
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26733 PyObject *resultobj = 0;
26734 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26735 wxWindow *arg2 = (wxWindow *) 0 ;
26736 void *argp1 = 0 ;
26737 int res1 = 0 ;
26738 void *argp2 = 0 ;
26739 int res2 = 0 ;
26740 PyObject * obj0 = 0 ;
26741 PyObject * obj1 = 0 ;
26742 char * kwnames[] = {
26743 (char *) "self",(char *) "win", NULL
26744 };
26745
26746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26748 if (!SWIG_IsOK(res1)) {
26749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26750 }
26751 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26753 if (!SWIG_IsOK(res2)) {
26754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26755 }
26756 arg2 = reinterpret_cast< wxWindow * >(argp2);
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 (arg1)->SetWindow(arg2);
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 resultobj = SWIG_Py_Void();
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771 PyObject *obj;
26772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26773 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26774 return SWIG_Py_Void();
26775 }
26776
26777 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778 return SWIG_Python_InitShadowInstance(args);
26779 }
26780
26781 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26782 PyObject *resultobj = 0;
26783 wxWindow *arg1 = (wxWindow *) NULL ;
26784 wxChildFocusEvent *result = 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 PyObject * obj0 = 0 ;
26788 char * kwnames[] = {
26789 (char *) "win", NULL
26790 };
26791
26792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26793 if (obj0) {
26794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26795 if (!SWIG_IsOK(res1)) {
26796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26797 }
26798 arg1 = reinterpret_cast< wxWindow * >(argp1);
26799 }
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26816 wxWindow *result = 0 ;
26817 void *argp1 = 0 ;
26818 int res1 = 0 ;
26819 PyObject *swig_obj[1] ;
26820
26821 if (!args) SWIG_fail;
26822 swig_obj[0] = args;
26823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26824 if (!SWIG_IsOK(res1)) {
26825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26826 }
26827 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 {
26835 resultobj = wxPyMake_wxObject(result, (bool)0);
26836 }
26837 return resultobj;
26838 fail:
26839 return NULL;
26840 }
26841
26842
26843 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26844 PyObject *obj;
26845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26846 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26847 return SWIG_Py_Void();
26848 }
26849
26850 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26851 return SWIG_Python_InitShadowInstance(args);
26852 }
26853
26854 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj = 0;
26856 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26857 bool arg2 = (bool) true ;
26858 int arg3 = (int) 0 ;
26859 wxActivateEvent *result = 0 ;
26860 int val1 ;
26861 int ecode1 = 0 ;
26862 bool val2 ;
26863 int ecode2 = 0 ;
26864 int val3 ;
26865 int ecode3 = 0 ;
26866 PyObject * obj0 = 0 ;
26867 PyObject * obj1 = 0 ;
26868 PyObject * obj2 = 0 ;
26869 char * kwnames[] = {
26870 (char *) "type",(char *) "active",(char *) "Id", NULL
26871 };
26872
26873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26874 if (obj0) {
26875 ecode1 = SWIG_AsVal_int(obj0, &val1);
26876 if (!SWIG_IsOK(ecode1)) {
26877 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26878 }
26879 arg1 = static_cast< wxEventType >(val1);
26880 }
26881 if (obj1) {
26882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26883 if (!SWIG_IsOK(ecode2)) {
26884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26885 }
26886 arg2 = static_cast< bool >(val2);
26887 }
26888 if (obj2) {
26889 ecode3 = SWIG_AsVal_int(obj2, &val3);
26890 if (!SWIG_IsOK(ecode3)) {
26891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26892 }
26893 arg3 = static_cast< int >(val3);
26894 }
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26898 wxPyEndAllowThreads(__tstate);
26899 if (PyErr_Occurred()) SWIG_fail;
26900 }
26901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26902 return resultobj;
26903 fail:
26904 return NULL;
26905 }
26906
26907
26908 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26909 PyObject *resultobj = 0;
26910 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26911 bool result;
26912 void *argp1 = 0 ;
26913 int res1 = 0 ;
26914 PyObject *swig_obj[1] ;
26915
26916 if (!args) SWIG_fail;
26917 swig_obj[0] = args;
26918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26919 if (!SWIG_IsOK(res1)) {
26920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26921 }
26922 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26926 wxPyEndAllowThreads(__tstate);
26927 if (PyErr_Occurred()) SWIG_fail;
26928 }
26929 {
26930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26931 }
26932 return resultobj;
26933 fail:
26934 return NULL;
26935 }
26936
26937
26938 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26939 PyObject *obj;
26940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26941 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26942 return SWIG_Py_Void();
26943 }
26944
26945 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26946 return SWIG_Python_InitShadowInstance(args);
26947 }
26948
26949 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26950 PyObject *resultobj = 0;
26951 int arg1 = (int) 0 ;
26952 wxInitDialogEvent *result = 0 ;
26953 int val1 ;
26954 int ecode1 = 0 ;
26955 PyObject * obj0 = 0 ;
26956 char * kwnames[] = {
26957 (char *) "Id", NULL
26958 };
26959
26960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26961 if (obj0) {
26962 ecode1 = SWIG_AsVal_int(obj0, &val1);
26963 if (!SWIG_IsOK(ecode1)) {
26964 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26965 }
26966 arg1 = static_cast< int >(val1);
26967 }
26968 {
26969 PyThreadState* __tstate = wxPyBeginAllowThreads();
26970 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26971 wxPyEndAllowThreads(__tstate);
26972 if (PyErr_Occurred()) SWIG_fail;
26973 }
26974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26982 PyObject *obj;
26983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26984 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26985 return SWIG_Py_Void();
26986 }
26987
26988 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26989 return SWIG_Python_InitShadowInstance(args);
26990 }
26991
26992 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj = 0;
26994 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26995 int arg2 = (int) 0 ;
26996 wxMenu *arg3 = (wxMenu *) NULL ;
26997 wxMenuEvent *result = 0 ;
26998 int val1 ;
26999 int ecode1 = 0 ;
27000 int val2 ;
27001 int ecode2 = 0 ;
27002 void *argp3 = 0 ;
27003 int res3 = 0 ;
27004 PyObject * obj0 = 0 ;
27005 PyObject * obj1 = 0 ;
27006 PyObject * obj2 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "type",(char *) "winid",(char *) "menu", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27012 if (obj0) {
27013 ecode1 = SWIG_AsVal_int(obj0, &val1);
27014 if (!SWIG_IsOK(ecode1)) {
27015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27016 }
27017 arg1 = static_cast< wxEventType >(val1);
27018 }
27019 if (obj1) {
27020 ecode2 = SWIG_AsVal_int(obj1, &val2);
27021 if (!SWIG_IsOK(ecode2)) {
27022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27023 }
27024 arg2 = static_cast< int >(val2);
27025 }
27026 if (obj2) {
27027 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27028 if (!SWIG_IsOK(res3)) {
27029 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27030 }
27031 arg3 = reinterpret_cast< wxMenu * >(argp3);
27032 }
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27049 int result;
27050 void *argp1 = 0 ;
27051 int res1 = 0 ;
27052 PyObject *swig_obj[1] ;
27053
27054 if (!args) SWIG_fail;
27055 swig_obj[0] = args;
27056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27057 if (!SWIG_IsOK(res1)) {
27058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27059 }
27060 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27061 {
27062 PyThreadState* __tstate = wxPyBeginAllowThreads();
27063 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 resultobj = SWIG_From_int(static_cast< int >(result));
27068 return resultobj;
27069 fail:
27070 return NULL;
27071 }
27072
27073
27074 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27075 PyObject *resultobj = 0;
27076 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27077 bool result;
27078 void *argp1 = 0 ;
27079 int res1 = 0 ;
27080 PyObject *swig_obj[1] ;
27081
27082 if (!args) SWIG_fail;
27083 swig_obj[0] = args;
27084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27085 if (!SWIG_IsOK(res1)) {
27086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27087 }
27088 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27092 wxPyEndAllowThreads(__tstate);
27093 if (PyErr_Occurred()) SWIG_fail;
27094 }
27095 {
27096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27097 }
27098 return resultobj;
27099 fail:
27100 return NULL;
27101 }
27102
27103
27104 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27105 PyObject *resultobj = 0;
27106 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27107 wxMenu *result = 0 ;
27108 void *argp1 = 0 ;
27109 int res1 = 0 ;
27110 PyObject *swig_obj[1] ;
27111
27112 if (!args) SWIG_fail;
27113 swig_obj[0] = args;
27114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27115 if (!SWIG_IsOK(res1)) {
27116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27117 }
27118 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27119 {
27120 PyThreadState* __tstate = wxPyBeginAllowThreads();
27121 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 {
27126 resultobj = wxPyMake_wxObject(result, (bool)0);
27127 }
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27135 PyObject *obj;
27136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27137 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27138 return SWIG_Py_Void();
27139 }
27140
27141 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27142 return SWIG_Python_InitShadowInstance(args);
27143 }
27144
27145 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27146 PyObject *resultobj = 0;
27147 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27148 int arg2 = (int) 0 ;
27149 wxCloseEvent *result = 0 ;
27150 int val1 ;
27151 int ecode1 = 0 ;
27152 int val2 ;
27153 int ecode2 = 0 ;
27154 PyObject * obj0 = 0 ;
27155 PyObject * obj1 = 0 ;
27156 char * kwnames[] = {
27157 (char *) "type",(char *) "winid", NULL
27158 };
27159
27160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27161 if (obj0) {
27162 ecode1 = SWIG_AsVal_int(obj0, &val1);
27163 if (!SWIG_IsOK(ecode1)) {
27164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27165 }
27166 arg1 = static_cast< wxEventType >(val1);
27167 }
27168 if (obj1) {
27169 ecode2 = SWIG_AsVal_int(obj1, &val2);
27170 if (!SWIG_IsOK(ecode2)) {
27171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27172 }
27173 arg2 = static_cast< int >(val2);
27174 }
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27178 wxPyEndAllowThreads(__tstate);
27179 if (PyErr_Occurred()) SWIG_fail;
27180 }
27181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27182 return resultobj;
27183 fail:
27184 return NULL;
27185 }
27186
27187
27188 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27189 PyObject *resultobj = 0;
27190 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27191 bool arg2 ;
27192 void *argp1 = 0 ;
27193 int res1 = 0 ;
27194 bool val2 ;
27195 int ecode2 = 0 ;
27196 PyObject * obj0 = 0 ;
27197 PyObject * obj1 = 0 ;
27198 char * kwnames[] = {
27199 (char *) "self",(char *) "logOff", NULL
27200 };
27201
27202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27206 }
27207 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27209 if (!SWIG_IsOK(ecode2)) {
27210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27211 }
27212 arg2 = static_cast< bool >(val2);
27213 {
27214 PyThreadState* __tstate = wxPyBeginAllowThreads();
27215 (arg1)->SetLoggingOff(arg2);
27216 wxPyEndAllowThreads(__tstate);
27217 if (PyErr_Occurred()) SWIG_fail;
27218 }
27219 resultobj = SWIG_Py_Void();
27220 return resultobj;
27221 fail:
27222 return NULL;
27223 }
27224
27225
27226 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27227 PyObject *resultobj = 0;
27228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27229 bool result;
27230 void *argp1 = 0 ;
27231 int res1 = 0 ;
27232 PyObject *swig_obj[1] ;
27233
27234 if (!args) SWIG_fail;
27235 swig_obj[0] = args;
27236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27237 if (!SWIG_IsOK(res1)) {
27238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27239 }
27240 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj = 0;
27258 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27259 bool arg2 = (bool) true ;
27260 void *argp1 = 0 ;
27261 int res1 = 0 ;
27262 bool val2 ;
27263 int ecode2 = 0 ;
27264 PyObject * obj0 = 0 ;
27265 PyObject * obj1 = 0 ;
27266 char * kwnames[] = {
27267 (char *) "self",(char *) "veto", NULL
27268 };
27269
27270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27272 if (!SWIG_IsOK(res1)) {
27273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27274 }
27275 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27276 if (obj1) {
27277 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27278 if (!SWIG_IsOK(ecode2)) {
27279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27280 }
27281 arg2 = static_cast< bool >(val2);
27282 }
27283 {
27284 PyThreadState* __tstate = wxPyBeginAllowThreads();
27285 (arg1)->Veto(arg2);
27286 wxPyEndAllowThreads(__tstate);
27287 if (PyErr_Occurred()) SWIG_fail;
27288 }
27289 resultobj = SWIG_Py_Void();
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27297 PyObject *resultobj = 0;
27298 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27299 bool result;
27300 void *argp1 = 0 ;
27301 int res1 = 0 ;
27302 PyObject *swig_obj[1] ;
27303
27304 if (!args) SWIG_fail;
27305 swig_obj[0] = args;
27306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27307 if (!SWIG_IsOK(res1)) {
27308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27309 }
27310 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27319 }
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = 0;
27328 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27329 bool arg2 ;
27330 void *argp1 = 0 ;
27331 int res1 = 0 ;
27332 bool val2 ;
27333 int ecode2 = 0 ;
27334 PyObject * obj0 = 0 ;
27335 PyObject * obj1 = 0 ;
27336 char * kwnames[] = {
27337 (char *) "self",(char *) "canVeto", NULL
27338 };
27339
27340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27342 if (!SWIG_IsOK(res1)) {
27343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27344 }
27345 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27347 if (!SWIG_IsOK(ecode2)) {
27348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27349 }
27350 arg2 = static_cast< bool >(val2);
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 (arg1)->SetCanVeto(arg2);
27354 wxPyEndAllowThreads(__tstate);
27355 if (PyErr_Occurred()) SWIG_fail;
27356 }
27357 resultobj = SWIG_Py_Void();
27358 return resultobj;
27359 fail:
27360 return NULL;
27361 }
27362
27363
27364 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27365 PyObject *resultobj = 0;
27366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27367 bool result;
27368 void *argp1 = 0 ;
27369 int res1 = 0 ;
27370 PyObject *swig_obj[1] ;
27371
27372 if (!args) SWIG_fail;
27373 swig_obj[0] = args;
27374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27375 if (!SWIG_IsOK(res1)) {
27376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27377 }
27378 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27379 {
27380 PyThreadState* __tstate = wxPyBeginAllowThreads();
27381 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27382 wxPyEndAllowThreads(__tstate);
27383 if (PyErr_Occurred()) SWIG_fail;
27384 }
27385 {
27386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27387 }
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27395 PyObject *obj;
27396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27397 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27398 return SWIG_Py_Void();
27399 }
27400
27401 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 return SWIG_Python_InitShadowInstance(args);
27403 }
27404
27405 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27406 PyObject *resultobj = 0;
27407 int arg1 = (int) 0 ;
27408 bool arg2 = (bool) false ;
27409 wxShowEvent *result = 0 ;
27410 int val1 ;
27411 int ecode1 = 0 ;
27412 bool val2 ;
27413 int ecode2 = 0 ;
27414 PyObject * obj0 = 0 ;
27415 PyObject * obj1 = 0 ;
27416 char * kwnames[] = {
27417 (char *) "winid",(char *) "show", NULL
27418 };
27419
27420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27421 if (obj0) {
27422 ecode1 = SWIG_AsVal_int(obj0, &val1);
27423 if (!SWIG_IsOK(ecode1)) {
27424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27425 }
27426 arg1 = static_cast< int >(val1);
27427 }
27428 if (obj1) {
27429 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27430 if (!SWIG_IsOK(ecode2)) {
27431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27432 }
27433 arg2 = static_cast< bool >(val2);
27434 }
27435 {
27436 PyThreadState* __tstate = wxPyBeginAllowThreads();
27437 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27442 return resultobj;
27443 fail:
27444 return NULL;
27445 }
27446
27447
27448 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27449 PyObject *resultobj = 0;
27450 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27451 bool arg2 ;
27452 void *argp1 = 0 ;
27453 int res1 = 0 ;
27454 bool val2 ;
27455 int ecode2 = 0 ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 char * kwnames[] = {
27459 (char *) "self",(char *) "show", NULL
27460 };
27461
27462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27466 }
27467 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27469 if (!SWIG_IsOK(ecode2)) {
27470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27471 }
27472 arg2 = static_cast< bool >(val2);
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 (arg1)->SetShow(arg2);
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 resultobj = SWIG_Py_Void();
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27487 PyObject *resultobj = 0;
27488 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27489 bool result;
27490 void *argp1 = 0 ;
27491 int res1 = 0 ;
27492 PyObject *swig_obj[1] ;
27493
27494 if (!args) SWIG_fail;
27495 swig_obj[0] = args;
27496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27497 if (!SWIG_IsOK(res1)) {
27498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27499 }
27500 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 {
27508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27509 }
27510 return resultobj;
27511 fail:
27512 return NULL;
27513 }
27514
27515
27516 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27517 PyObject *obj;
27518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27519 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27520 return SWIG_Py_Void();
27521 }
27522
27523 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27524 return SWIG_Python_InitShadowInstance(args);
27525 }
27526
27527 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27528 PyObject *resultobj = 0;
27529 int arg1 = (int) 0 ;
27530 bool arg2 = (bool) true ;
27531 wxIconizeEvent *result = 0 ;
27532 int val1 ;
27533 int ecode1 = 0 ;
27534 bool val2 ;
27535 int ecode2 = 0 ;
27536 PyObject * obj0 = 0 ;
27537 PyObject * obj1 = 0 ;
27538 char * kwnames[] = {
27539 (char *) "id",(char *) "iconized", NULL
27540 };
27541
27542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27543 if (obj0) {
27544 ecode1 = SWIG_AsVal_int(obj0, &val1);
27545 if (!SWIG_IsOK(ecode1)) {
27546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27547 }
27548 arg1 = static_cast< int >(val1);
27549 }
27550 if (obj1) {
27551 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27552 if (!SWIG_IsOK(ecode2)) {
27553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27554 }
27555 arg2 = static_cast< bool >(val2);
27556 }
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27564 return resultobj;
27565 fail:
27566 return NULL;
27567 }
27568
27569
27570 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27571 PyObject *resultobj = 0;
27572 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27573 bool result;
27574 void *argp1 = 0 ;
27575 int res1 = 0 ;
27576 PyObject *swig_obj[1] ;
27577
27578 if (!args) SWIG_fail;
27579 swig_obj[0] = args;
27580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27581 if (!SWIG_IsOK(res1)) {
27582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27583 }
27584 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27585 {
27586 PyThreadState* __tstate = wxPyBeginAllowThreads();
27587 result = (bool)(arg1)->Iconized();
27588 wxPyEndAllowThreads(__tstate);
27589 if (PyErr_Occurred()) SWIG_fail;
27590 }
27591 {
27592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27593 }
27594 return resultobj;
27595 fail:
27596 return NULL;
27597 }
27598
27599
27600 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27601 PyObject *obj;
27602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27603 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27604 return SWIG_Py_Void();
27605 }
27606
27607 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27608 return SWIG_Python_InitShadowInstance(args);
27609 }
27610
27611 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27612 PyObject *resultobj = 0;
27613 int arg1 = (int) 0 ;
27614 wxMaximizeEvent *result = 0 ;
27615 int val1 ;
27616 int ecode1 = 0 ;
27617 PyObject * obj0 = 0 ;
27618 char * kwnames[] = {
27619 (char *) "id", NULL
27620 };
27621
27622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27623 if (obj0) {
27624 ecode1 = SWIG_AsVal_int(obj0, &val1);
27625 if (!SWIG_IsOK(ecode1)) {
27626 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27627 }
27628 arg1 = static_cast< int >(val1);
27629 }
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27637 return resultobj;
27638 fail:
27639 return NULL;
27640 }
27641
27642
27643 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27644 PyObject *obj;
27645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27646 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27647 return SWIG_Py_Void();
27648 }
27649
27650 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27651 return SWIG_Python_InitShadowInstance(args);
27652 }
27653
27654 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27655 PyObject *resultobj = 0;
27656 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27657 wxPoint result;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 PyObject *swig_obj[1] ;
27661
27662 if (!args) SWIG_fail;
27663 swig_obj[0] = args;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27667 }
27668 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = (arg1)->GetPosition();
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27676 return resultobj;
27677 fail:
27678 return NULL;
27679 }
27680
27681
27682 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27683 PyObject *resultobj = 0;
27684 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27685 int result;
27686 void *argp1 = 0 ;
27687 int res1 = 0 ;
27688 PyObject *swig_obj[1] ;
27689
27690 if (!args) SWIG_fail;
27691 swig_obj[0] = args;
27692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27693 if (!SWIG_IsOK(res1)) {
27694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27695 }
27696 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 result = (int)(arg1)->GetNumberOfFiles();
27700 wxPyEndAllowThreads(__tstate);
27701 if (PyErr_Occurred()) SWIG_fail;
27702 }
27703 resultobj = SWIG_From_int(static_cast< int >(result));
27704 return resultobj;
27705 fail:
27706 return NULL;
27707 }
27708
27709
27710 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27711 PyObject *resultobj = 0;
27712 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27713 PyObject *result = 0 ;
27714 void *argp1 = 0 ;
27715 int res1 = 0 ;
27716 PyObject *swig_obj[1] ;
27717
27718 if (!args) SWIG_fail;
27719 swig_obj[0] = args;
27720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27721 if (!SWIG_IsOK(res1)) {
27722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27723 }
27724 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27725 {
27726 PyThreadState* __tstate = wxPyBeginAllowThreads();
27727 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27728 wxPyEndAllowThreads(__tstate);
27729 if (PyErr_Occurred()) SWIG_fail;
27730 }
27731 resultobj = result;
27732 return resultobj;
27733 fail:
27734 return NULL;
27735 }
27736
27737
27738 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27739 PyObject *obj;
27740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27741 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27742 return SWIG_Py_Void();
27743 }
27744
27745 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27746 PyObject *resultobj = 0;
27747 int arg1 = (int) 0 ;
27748 wxUpdateUIEvent *result = 0 ;
27749 int val1 ;
27750 int ecode1 = 0 ;
27751 PyObject * obj0 = 0 ;
27752 char * kwnames[] = {
27753 (char *) "commandId", NULL
27754 };
27755
27756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27757 if (obj0) {
27758 ecode1 = SWIG_AsVal_int(obj0, &val1);
27759 if (!SWIG_IsOK(ecode1)) {
27760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27761 }
27762 arg1 = static_cast< int >(val1);
27763 }
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27778 PyObject *resultobj = 0;
27779 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27780 bool result;
27781 void *argp1 = 0 ;
27782 int res1 = 0 ;
27783 PyObject *swig_obj[1] ;
27784
27785 if (!args) SWIG_fail;
27786 swig_obj[0] = args;
27787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27788 if (!SWIG_IsOK(res1)) {
27789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27790 }
27791 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27792 {
27793 PyThreadState* __tstate = wxPyBeginAllowThreads();
27794 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27795 wxPyEndAllowThreads(__tstate);
27796 if (PyErr_Occurred()) SWIG_fail;
27797 }
27798 {
27799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27800 }
27801 return resultobj;
27802 fail:
27803 return NULL;
27804 }
27805
27806
27807 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27808 PyObject *resultobj = 0;
27809 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27810 bool result;
27811 void *argp1 = 0 ;
27812 int res1 = 0 ;
27813 PyObject *swig_obj[1] ;
27814
27815 if (!args) SWIG_fail;
27816 swig_obj[0] = args;
27817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27818 if (!SWIG_IsOK(res1)) {
27819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27820 }
27821 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27822 {
27823 PyThreadState* __tstate = wxPyBeginAllowThreads();
27824 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27825 wxPyEndAllowThreads(__tstate);
27826 if (PyErr_Occurred()) SWIG_fail;
27827 }
27828 {
27829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27830 }
27831 return resultobj;
27832 fail:
27833 return NULL;
27834 }
27835
27836
27837 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27838 PyObject *resultobj = 0;
27839 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27840 bool result;
27841 void *argp1 = 0 ;
27842 int res1 = 0 ;
27843 PyObject *swig_obj[1] ;
27844
27845 if (!args) SWIG_fail;
27846 swig_obj[0] = args;
27847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27848 if (!SWIG_IsOK(res1)) {
27849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27850 }
27851 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27870 wxString result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 PyObject *swig_obj[1] ;
27874
27875 if (!args) SWIG_fail;
27876 swig_obj[0] = args;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27880 }
27881 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 {
27889 #if wxUSE_UNICODE
27890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27891 #else
27892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27893 #endif
27894 }
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27902 PyObject *resultobj = 0;
27903 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27904 bool result;
27905 void *argp1 = 0 ;
27906 int res1 = 0 ;
27907 PyObject *swig_obj[1] ;
27908
27909 if (!args) SWIG_fail;
27910 swig_obj[0] = args;
27911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27914 }
27915 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 {
27923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27924 }
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27932 PyObject *resultobj = 0;
27933 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27934 bool result;
27935 void *argp1 = 0 ;
27936 int res1 = 0 ;
27937 PyObject *swig_obj[1] ;
27938
27939 if (!args) SWIG_fail;
27940 swig_obj[0] = args;
27941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27942 if (!SWIG_IsOK(res1)) {
27943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27944 }
27945 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27962 PyObject *resultobj = 0;
27963 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27964 bool result;
27965 void *argp1 = 0 ;
27966 int res1 = 0 ;
27967 PyObject *swig_obj[1] ;
27968
27969 if (!args) SWIG_fail;
27970 swig_obj[0] = args;
27971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27972 if (!SWIG_IsOK(res1)) {
27973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27974 }
27975 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27976 {
27977 PyThreadState* __tstate = wxPyBeginAllowThreads();
27978 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27979 wxPyEndAllowThreads(__tstate);
27980 if (PyErr_Occurred()) SWIG_fail;
27981 }
27982 {
27983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27984 }
27985 return resultobj;
27986 fail:
27987 return NULL;
27988 }
27989
27990
27991 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27992 PyObject *resultobj = 0;
27993 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27994 bool result;
27995 void *argp1 = 0 ;
27996 int res1 = 0 ;
27997 PyObject *swig_obj[1] ;
27998
27999 if (!args) SWIG_fail;
28000 swig_obj[0] = args;
28001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28002 if (!SWIG_IsOK(res1)) {
28003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28004 }
28005 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28006 {
28007 PyThreadState* __tstate = wxPyBeginAllowThreads();
28008 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj = 0;
28023 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28024 bool arg2 ;
28025 void *argp1 = 0 ;
28026 int res1 = 0 ;
28027 bool val2 ;
28028 int ecode2 = 0 ;
28029 PyObject * obj0 = 0 ;
28030 PyObject * obj1 = 0 ;
28031 char * kwnames[] = {
28032 (char *) "self",(char *) "check", NULL
28033 };
28034
28035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28037 if (!SWIG_IsOK(res1)) {
28038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28039 }
28040 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28041 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28042 if (!SWIG_IsOK(ecode2)) {
28043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28044 }
28045 arg2 = static_cast< bool >(val2);
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 (arg1)->Check(arg2);
28049 wxPyEndAllowThreads(__tstate);
28050 if (PyErr_Occurred()) SWIG_fail;
28051 }
28052 resultobj = SWIG_Py_Void();
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj = 0;
28061 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28062 bool arg2 ;
28063 void *argp1 = 0 ;
28064 int res1 = 0 ;
28065 bool val2 ;
28066 int ecode2 = 0 ;
28067 PyObject * obj0 = 0 ;
28068 PyObject * obj1 = 0 ;
28069 char * kwnames[] = {
28070 (char *) "self",(char *) "enable", NULL
28071 };
28072
28073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28075 if (!SWIG_IsOK(res1)) {
28076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28077 }
28078 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28080 if (!SWIG_IsOK(ecode2)) {
28081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28082 }
28083 arg2 = static_cast< bool >(val2);
28084 {
28085 PyThreadState* __tstate = wxPyBeginAllowThreads();
28086 (arg1)->Enable(arg2);
28087 wxPyEndAllowThreads(__tstate);
28088 if (PyErr_Occurred()) SWIG_fail;
28089 }
28090 resultobj = SWIG_Py_Void();
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28098 PyObject *resultobj = 0;
28099 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28100 bool arg2 ;
28101 void *argp1 = 0 ;
28102 int res1 = 0 ;
28103 bool val2 ;
28104 int ecode2 = 0 ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 char * kwnames[] = {
28108 (char *) "self",(char *) "show", NULL
28109 };
28110
28111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28113 if (!SWIG_IsOK(res1)) {
28114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28115 }
28116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28118 if (!SWIG_IsOK(ecode2)) {
28119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28120 }
28121 arg2 = static_cast< bool >(val2);
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 (arg1)->Show(arg2);
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = SWIG_Py_Void();
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28136 PyObject *resultobj = 0;
28137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28138 wxString *arg2 = 0 ;
28139 void *argp1 = 0 ;
28140 int res1 = 0 ;
28141 bool temp2 = false ;
28142 PyObject * obj0 = 0 ;
28143 PyObject * obj1 = 0 ;
28144 char * kwnames[] = {
28145 (char *) "self",(char *) "text", NULL
28146 };
28147
28148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28150 if (!SWIG_IsOK(res1)) {
28151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28152 }
28153 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28154 {
28155 arg2 = wxString_in_helper(obj1);
28156 if (arg2 == NULL) SWIG_fail;
28157 temp2 = true;
28158 }
28159 {
28160 PyThreadState* __tstate = wxPyBeginAllowThreads();
28161 (arg1)->SetText((wxString const &)*arg2);
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 resultobj = SWIG_Py_Void();
28166 {
28167 if (temp2)
28168 delete arg2;
28169 }
28170 return resultobj;
28171 fail:
28172 {
28173 if (temp2)
28174 delete arg2;
28175 }
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj = 0;
28182 long arg1 ;
28183 long val1 ;
28184 int ecode1 = 0 ;
28185 PyObject * obj0 = 0 ;
28186 char * kwnames[] = {
28187 (char *) "updateInterval", NULL
28188 };
28189
28190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28191 ecode1 = SWIG_AsVal_long(obj0, &val1);
28192 if (!SWIG_IsOK(ecode1)) {
28193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28194 }
28195 arg1 = static_cast< long >(val1);
28196 {
28197 PyThreadState* __tstate = wxPyBeginAllowThreads();
28198 wxUpdateUIEvent::SetUpdateInterval(arg1);
28199 wxPyEndAllowThreads(__tstate);
28200 if (PyErr_Occurred()) SWIG_fail;
28201 }
28202 resultobj = SWIG_Py_Void();
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28210 PyObject *resultobj = 0;
28211 long result;
28212
28213 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28217 wxPyEndAllowThreads(__tstate);
28218 if (PyErr_Occurred()) SWIG_fail;
28219 }
28220 resultobj = SWIG_From_long(static_cast< long >(result));
28221 return resultobj;
28222 fail:
28223 return NULL;
28224 }
28225
28226
28227 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28228 PyObject *resultobj = 0;
28229 wxWindow *arg1 = (wxWindow *) 0 ;
28230 bool result;
28231 void *argp1 = 0 ;
28232 int res1 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 char * kwnames[] = {
28235 (char *) "win", NULL
28236 };
28237
28238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28240 if (!SWIG_IsOK(res1)) {
28241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28242 }
28243 arg1 = reinterpret_cast< wxWindow * >(argp1);
28244 {
28245 PyThreadState* __tstate = wxPyBeginAllowThreads();
28246 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28247 wxPyEndAllowThreads(__tstate);
28248 if (PyErr_Occurred()) SWIG_fail;
28249 }
28250 {
28251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28252 }
28253 return resultobj;
28254 fail:
28255 return NULL;
28256 }
28257
28258
28259 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28260 PyObject *resultobj = 0;
28261
28262 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28263 {
28264 PyThreadState* __tstate = wxPyBeginAllowThreads();
28265 wxUpdateUIEvent::ResetUpdateTime();
28266 wxPyEndAllowThreads(__tstate);
28267 if (PyErr_Occurred()) SWIG_fail;
28268 }
28269 resultobj = SWIG_Py_Void();
28270 return resultobj;
28271 fail:
28272 return NULL;
28273 }
28274
28275
28276 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28277 PyObject *resultobj = 0;
28278 wxUpdateUIMode arg1 ;
28279 int val1 ;
28280 int ecode1 = 0 ;
28281 PyObject * obj0 = 0 ;
28282 char * kwnames[] = {
28283 (char *) "mode", NULL
28284 };
28285
28286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28287 ecode1 = SWIG_AsVal_int(obj0, &val1);
28288 if (!SWIG_IsOK(ecode1)) {
28289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28290 }
28291 arg1 = static_cast< wxUpdateUIMode >(val1);
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 wxUpdateUIEvent::SetMode(arg1);
28295 wxPyEndAllowThreads(__tstate);
28296 if (PyErr_Occurred()) SWIG_fail;
28297 }
28298 resultobj = SWIG_Py_Void();
28299 return resultobj;
28300 fail:
28301 return NULL;
28302 }
28303
28304
28305 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28306 PyObject *resultobj = 0;
28307 wxUpdateUIMode result;
28308
28309 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28313 wxPyEndAllowThreads(__tstate);
28314 if (PyErr_Occurred()) SWIG_fail;
28315 }
28316 resultobj = SWIG_From_int(static_cast< int >(result));
28317 return resultobj;
28318 fail:
28319 return NULL;
28320 }
28321
28322
28323 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28324 PyObject *obj;
28325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28326 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28327 return SWIG_Py_Void();
28328 }
28329
28330 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28331 return SWIG_Python_InitShadowInstance(args);
28332 }
28333
28334 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28335 PyObject *resultobj = 0;
28336 wxSysColourChangedEvent *result = 0 ;
28337
28338 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28346 return resultobj;
28347 fail:
28348 return NULL;
28349 }
28350
28351
28352 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28353 PyObject *obj;
28354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28355 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28356 return SWIG_Py_Void();
28357 }
28358
28359 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 return SWIG_Python_InitShadowInstance(args);
28361 }
28362
28363 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj = 0;
28365 int arg1 = (int) 0 ;
28366 wxWindow *arg2 = (wxWindow *) NULL ;
28367 wxMouseCaptureChangedEvent *result = 0 ;
28368 int val1 ;
28369 int ecode1 = 0 ;
28370 void *argp2 = 0 ;
28371 int res2 = 0 ;
28372 PyObject * obj0 = 0 ;
28373 PyObject * obj1 = 0 ;
28374 char * kwnames[] = {
28375 (char *) "winid",(char *) "gainedCapture", NULL
28376 };
28377
28378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28379 if (obj0) {
28380 ecode1 = SWIG_AsVal_int(obj0, &val1);
28381 if (!SWIG_IsOK(ecode1)) {
28382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28383 }
28384 arg1 = static_cast< int >(val1);
28385 }
28386 if (obj1) {
28387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28388 if (!SWIG_IsOK(res2)) {
28389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28390 }
28391 arg2 = reinterpret_cast< wxWindow * >(argp2);
28392 }
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28407 PyObject *resultobj = 0;
28408 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28409 wxWindow *result = 0 ;
28410 void *argp1 = 0 ;
28411 int res1 = 0 ;
28412 PyObject *swig_obj[1] ;
28413
28414 if (!args) SWIG_fail;
28415 swig_obj[0] = args;
28416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28417 if (!SWIG_IsOK(res1)) {
28418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28419 }
28420 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 {
28428 resultobj = wxPyMake_wxObject(result, (bool)0);
28429 }
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28437 PyObject *obj;
28438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28439 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28440 return SWIG_Py_Void();
28441 }
28442
28443 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28444 return SWIG_Python_InitShadowInstance(args);
28445 }
28446
28447 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28448 PyObject *resultobj = 0;
28449 int arg1 = (int) 0 ;
28450 wxMouseCaptureLostEvent *result = 0 ;
28451 int val1 ;
28452 int ecode1 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 char * kwnames[] = {
28455 (char *) "winid", NULL
28456 };
28457
28458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28459 if (obj0) {
28460 ecode1 = SWIG_AsVal_int(obj0, &val1);
28461 if (!SWIG_IsOK(ecode1)) {
28462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28463 }
28464 arg1 = static_cast< int >(val1);
28465 }
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28480 PyObject *obj;
28481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28482 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28483 return SWIG_Py_Void();
28484 }
28485
28486 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28487 return SWIG_Python_InitShadowInstance(args);
28488 }
28489
28490 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28491 PyObject *resultobj = 0;
28492 wxDisplayChangedEvent *result = 0 ;
28493
28494 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28495 {
28496 PyThreadState* __tstate = wxPyBeginAllowThreads();
28497 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28509 PyObject *obj;
28510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28511 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28512 return SWIG_Py_Void();
28513 }
28514
28515 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28516 return SWIG_Python_InitShadowInstance(args);
28517 }
28518
28519 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj = 0;
28521 int arg1 = (int) 0 ;
28522 wxPaletteChangedEvent *result = 0 ;
28523 int val1 ;
28524 int ecode1 = 0 ;
28525 PyObject * obj0 = 0 ;
28526 char * kwnames[] = {
28527 (char *) "id", NULL
28528 };
28529
28530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28531 if (obj0) {
28532 ecode1 = SWIG_AsVal_int(obj0, &val1);
28533 if (!SWIG_IsOK(ecode1)) {
28534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28535 }
28536 arg1 = static_cast< int >(val1);
28537 }
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj = 0;
28553 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28554 wxWindow *arg2 = (wxWindow *) 0 ;
28555 void *argp1 = 0 ;
28556 int res1 = 0 ;
28557 void *argp2 = 0 ;
28558 int res2 = 0 ;
28559 PyObject * obj0 = 0 ;
28560 PyObject * obj1 = 0 ;
28561 char * kwnames[] = {
28562 (char *) "self",(char *) "win", NULL
28563 };
28564
28565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28567 if (!SWIG_IsOK(res1)) {
28568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28569 }
28570 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28572 if (!SWIG_IsOK(res2)) {
28573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28574 }
28575 arg2 = reinterpret_cast< wxWindow * >(argp2);
28576 {
28577 PyThreadState* __tstate = wxPyBeginAllowThreads();
28578 (arg1)->SetChangedWindow(arg2);
28579 wxPyEndAllowThreads(__tstate);
28580 if (PyErr_Occurred()) SWIG_fail;
28581 }
28582 resultobj = SWIG_Py_Void();
28583 return resultobj;
28584 fail:
28585 return NULL;
28586 }
28587
28588
28589 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28590 PyObject *resultobj = 0;
28591 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28592 wxWindow *result = 0 ;
28593 void *argp1 = 0 ;
28594 int res1 = 0 ;
28595 PyObject *swig_obj[1] ;
28596
28597 if (!args) SWIG_fail;
28598 swig_obj[0] = args;
28599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28600 if (!SWIG_IsOK(res1)) {
28601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28602 }
28603 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28604 {
28605 PyThreadState* __tstate = wxPyBeginAllowThreads();
28606 result = (wxWindow *)(arg1)->GetChangedWindow();
28607 wxPyEndAllowThreads(__tstate);
28608 if (PyErr_Occurred()) SWIG_fail;
28609 }
28610 {
28611 resultobj = wxPyMake_wxObject(result, (bool)0);
28612 }
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *obj;
28621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28622 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28623 return SWIG_Py_Void();
28624 }
28625
28626 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28627 return SWIG_Python_InitShadowInstance(args);
28628 }
28629
28630 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28631 PyObject *resultobj = 0;
28632 int arg1 = (int) 0 ;
28633 wxQueryNewPaletteEvent *result = 0 ;
28634 int val1 ;
28635 int ecode1 = 0 ;
28636 PyObject * obj0 = 0 ;
28637 char * kwnames[] = {
28638 (char *) "winid", NULL
28639 };
28640
28641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28642 if (obj0) {
28643 ecode1 = SWIG_AsVal_int(obj0, &val1);
28644 if (!SWIG_IsOK(ecode1)) {
28645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28646 }
28647 arg1 = static_cast< int >(val1);
28648 }
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28665 bool arg2 ;
28666 void *argp1 = 0 ;
28667 int res1 = 0 ;
28668 bool val2 ;
28669 int ecode2 = 0 ;
28670 PyObject * obj0 = 0 ;
28671 PyObject * obj1 = 0 ;
28672 char * kwnames[] = {
28673 (char *) "self",(char *) "realized", NULL
28674 };
28675
28676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28678 if (!SWIG_IsOK(res1)) {
28679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28680 }
28681 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28682 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28683 if (!SWIG_IsOK(ecode2)) {
28684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28685 }
28686 arg2 = static_cast< bool >(val2);
28687 {
28688 PyThreadState* __tstate = wxPyBeginAllowThreads();
28689 (arg1)->SetPaletteRealized(arg2);
28690 wxPyEndAllowThreads(__tstate);
28691 if (PyErr_Occurred()) SWIG_fail;
28692 }
28693 resultobj = SWIG_Py_Void();
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28701 PyObject *resultobj = 0;
28702 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28703 bool result;
28704 void *argp1 = 0 ;
28705 int res1 = 0 ;
28706 PyObject *swig_obj[1] ;
28707
28708 if (!args) SWIG_fail;
28709 swig_obj[0] = args;
28710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28711 if (!SWIG_IsOK(res1)) {
28712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28713 }
28714 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 {
28722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28723 }
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28731 PyObject *obj;
28732 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28733 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28734 return SWIG_Py_Void();
28735 }
28736
28737 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28738 return SWIG_Python_InitShadowInstance(args);
28739 }
28740
28741 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28742 PyObject *resultobj = 0;
28743 wxNavigationKeyEvent *result = 0 ;
28744
28745 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28746 {
28747 PyThreadState* __tstate = wxPyBeginAllowThreads();
28748 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28760 PyObject *resultobj = 0;
28761 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28762 bool result;
28763 void *argp1 = 0 ;
28764 int res1 = 0 ;
28765 PyObject *swig_obj[1] ;
28766
28767 if (!args) SWIG_fail;
28768 swig_obj[0] = args;
28769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28770 if (!SWIG_IsOK(res1)) {
28771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28772 }
28773 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28774 {
28775 PyThreadState* __tstate = wxPyBeginAllowThreads();
28776 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 {
28781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28782 }
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj = 0;
28791 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28792 bool arg2 ;
28793 void *argp1 = 0 ;
28794 int res1 = 0 ;
28795 bool val2 ;
28796 int ecode2 = 0 ;
28797 PyObject * obj0 = 0 ;
28798 PyObject * obj1 = 0 ;
28799 char * kwnames[] = {
28800 (char *) "self",(char *) "forward", NULL
28801 };
28802
28803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28805 if (!SWIG_IsOK(res1)) {
28806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28807 }
28808 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28809 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28810 if (!SWIG_IsOK(ecode2)) {
28811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28812 }
28813 arg2 = static_cast< bool >(val2);
28814 {
28815 PyThreadState* __tstate = wxPyBeginAllowThreads();
28816 (arg1)->SetDirection(arg2);
28817 wxPyEndAllowThreads(__tstate);
28818 if (PyErr_Occurred()) SWIG_fail;
28819 }
28820 resultobj = SWIG_Py_Void();
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28828 PyObject *resultobj = 0;
28829 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28830 bool result;
28831 void *argp1 = 0 ;
28832 int res1 = 0 ;
28833 PyObject *swig_obj[1] ;
28834
28835 if (!args) SWIG_fail;
28836 swig_obj[0] = args;
28837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28838 if (!SWIG_IsOK(res1)) {
28839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28840 }
28841 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28845 wxPyEndAllowThreads(__tstate);
28846 if (PyErr_Occurred()) SWIG_fail;
28847 }
28848 {
28849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28850 }
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj = 0;
28859 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28860 bool arg2 ;
28861 void *argp1 = 0 ;
28862 int res1 = 0 ;
28863 bool val2 ;
28864 int ecode2 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 PyObject * obj1 = 0 ;
28867 char * kwnames[] = {
28868 (char *) "self",(char *) "ischange", NULL
28869 };
28870
28871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28875 }
28876 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28878 if (!SWIG_IsOK(ecode2)) {
28879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28880 }
28881 arg2 = static_cast< bool >(val2);
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 (arg1)->SetWindowChange(arg2);
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 resultobj = SWIG_Py_Void();
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28896 PyObject *resultobj = 0;
28897 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28898 bool result;
28899 void *argp1 = 0 ;
28900 int res1 = 0 ;
28901 PyObject *swig_obj[1] ;
28902
28903 if (!args) SWIG_fail;
28904 swig_obj[0] = args;
28905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28908 }
28909 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 {
28917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28918 }
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28926 PyObject *resultobj = 0;
28927 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28928 bool arg2 ;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 bool val2 ;
28932 int ecode2 = 0 ;
28933 PyObject * obj0 = 0 ;
28934 PyObject * obj1 = 0 ;
28935 char * kwnames[] = {
28936 (char *) "self",(char *) "bIs", NULL
28937 };
28938
28939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28941 if (!SWIG_IsOK(res1)) {
28942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28943 }
28944 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28945 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28946 if (!SWIG_IsOK(ecode2)) {
28947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28948 }
28949 arg2 = static_cast< bool >(val2);
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 (arg1)->SetFromTab(arg2);
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 resultobj = SWIG_Py_Void();
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28964 PyObject *resultobj = 0;
28965 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28966 long arg2 ;
28967 void *argp1 = 0 ;
28968 int res1 = 0 ;
28969 long val2 ;
28970 int ecode2 = 0 ;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 char * kwnames[] = {
28974 (char *) "self",(char *) "flags", NULL
28975 };
28976
28977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28981 }
28982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28983 ecode2 = SWIG_AsVal_long(obj1, &val2);
28984 if (!SWIG_IsOK(ecode2)) {
28985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28986 }
28987 arg2 = static_cast< long >(val2);
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 (arg1)->SetFlags(arg2);
28991 wxPyEndAllowThreads(__tstate);
28992 if (PyErr_Occurred()) SWIG_fail;
28993 }
28994 resultobj = SWIG_Py_Void();
28995 return resultobj;
28996 fail:
28997 return NULL;
28998 }
28999
29000
29001 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29002 PyObject *resultobj = 0;
29003 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29004 wxWindow *result = 0 ;
29005 void *argp1 = 0 ;
29006 int res1 = 0 ;
29007 PyObject *swig_obj[1] ;
29008
29009 if (!args) SWIG_fail;
29010 swig_obj[0] = args;
29011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29012 if (!SWIG_IsOK(res1)) {
29013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29014 }
29015 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29019 wxPyEndAllowThreads(__tstate);
29020 if (PyErr_Occurred()) SWIG_fail;
29021 }
29022 {
29023 resultobj = wxPyMake_wxObject(result, (bool)0);
29024 }
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj = 0;
29033 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29034 wxWindow *arg2 = (wxWindow *) 0 ;
29035 void *argp1 = 0 ;
29036 int res1 = 0 ;
29037 void *argp2 = 0 ;
29038 int res2 = 0 ;
29039 PyObject * obj0 = 0 ;
29040 PyObject * obj1 = 0 ;
29041 char * kwnames[] = {
29042 (char *) "self",(char *) "win", NULL
29043 };
29044
29045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29047 if (!SWIG_IsOK(res1)) {
29048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29049 }
29050 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29051 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29052 if (!SWIG_IsOK(res2)) {
29053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29054 }
29055 arg2 = reinterpret_cast< wxWindow * >(argp2);
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 (arg1)->SetCurrentFocus(arg2);
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 resultobj = SWIG_Py_Void();
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29070 PyObject *obj;
29071 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29072 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29073 return SWIG_Py_Void();
29074 }
29075
29076 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29077 return SWIG_Python_InitShadowInstance(args);
29078 }
29079
29080 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29081 PyObject *resultobj = 0;
29082 wxWindow *arg1 = (wxWindow *) NULL ;
29083 wxWindowCreateEvent *result = 0 ;
29084 void *argp1 = 0 ;
29085 int res1 = 0 ;
29086 PyObject * obj0 = 0 ;
29087 char * kwnames[] = {
29088 (char *) "win", NULL
29089 };
29090
29091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29092 if (obj0) {
29093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29096 }
29097 arg1 = reinterpret_cast< wxWindow * >(argp1);
29098 }
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29113 PyObject *resultobj = 0;
29114 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29115 wxWindow *result = 0 ;
29116 void *argp1 = 0 ;
29117 int res1 = 0 ;
29118 PyObject *swig_obj[1] ;
29119
29120 if (!args) SWIG_fail;
29121 swig_obj[0] = args;
29122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29123 if (!SWIG_IsOK(res1)) {
29124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29125 }
29126 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29127 {
29128 PyThreadState* __tstate = wxPyBeginAllowThreads();
29129 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 resultobj = wxPyMake_wxObject(result, (bool)0);
29135 }
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29143 PyObject *obj;
29144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29145 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29146 return SWIG_Py_Void();
29147 }
29148
29149 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29150 return SWIG_Python_InitShadowInstance(args);
29151 }
29152
29153 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj = 0;
29155 wxWindow *arg1 = (wxWindow *) NULL ;
29156 wxWindowDestroyEvent *result = 0 ;
29157 void *argp1 = 0 ;
29158 int res1 = 0 ;
29159 PyObject * obj0 = 0 ;
29160 char * kwnames[] = {
29161 (char *) "win", NULL
29162 };
29163
29164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29165 if (obj0) {
29166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29167 if (!SWIG_IsOK(res1)) {
29168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29169 }
29170 arg1 = reinterpret_cast< wxWindow * >(argp1);
29171 }
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29186 PyObject *resultobj = 0;
29187 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29188 wxWindow *result = 0 ;
29189 void *argp1 = 0 ;
29190 int res1 = 0 ;
29191 PyObject *swig_obj[1] ;
29192
29193 if (!args) SWIG_fail;
29194 swig_obj[0] = args;
29195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29196 if (!SWIG_IsOK(res1)) {
29197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29198 }
29199 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 {
29207 resultobj = wxPyMake_wxObject(result, (bool)0);
29208 }
29209 return resultobj;
29210 fail:
29211 return NULL;
29212 }
29213
29214
29215 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29216 PyObject *obj;
29217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29218 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29219 return SWIG_Py_Void();
29220 }
29221
29222 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 return SWIG_Python_InitShadowInstance(args);
29224 }
29225
29226 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29227 PyObject *resultobj = 0;
29228 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29229 int arg2 = (int) 0 ;
29230 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29231 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29232 wxContextMenuEvent *result = 0 ;
29233 int val1 ;
29234 int ecode1 = 0 ;
29235 int val2 ;
29236 int ecode2 = 0 ;
29237 wxPoint temp3 ;
29238 PyObject * obj0 = 0 ;
29239 PyObject * obj1 = 0 ;
29240 PyObject * obj2 = 0 ;
29241 char * kwnames[] = {
29242 (char *) "type",(char *) "winid",(char *) "pt", NULL
29243 };
29244
29245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29246 if (obj0) {
29247 ecode1 = SWIG_AsVal_int(obj0, &val1);
29248 if (!SWIG_IsOK(ecode1)) {
29249 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29250 }
29251 arg1 = static_cast< wxEventType >(val1);
29252 }
29253 if (obj1) {
29254 ecode2 = SWIG_AsVal_int(obj1, &val2);
29255 if (!SWIG_IsOK(ecode2)) {
29256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29257 }
29258 arg2 = static_cast< int >(val2);
29259 }
29260 if (obj2) {
29261 {
29262 arg3 = &temp3;
29263 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29264 }
29265 }
29266 {
29267 PyThreadState* __tstate = wxPyBeginAllowThreads();
29268 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29269 wxPyEndAllowThreads(__tstate);
29270 if (PyErr_Occurred()) SWIG_fail;
29271 }
29272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29273 return resultobj;
29274 fail:
29275 return NULL;
29276 }
29277
29278
29279 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 PyObject *resultobj = 0;
29281 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29282 wxPoint *result = 0 ;
29283 void *argp1 = 0 ;
29284 int res1 = 0 ;
29285 PyObject *swig_obj[1] ;
29286
29287 if (!args) SWIG_fail;
29288 swig_obj[0] = args;
29289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29290 if (!SWIG_IsOK(res1)) {
29291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29292 }
29293 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29294 {
29295 PyThreadState* __tstate = wxPyBeginAllowThreads();
29296 {
29297 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29298 result = (wxPoint *) &_result_ref;
29299 }
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29304 return resultobj;
29305 fail:
29306 return NULL;
29307 }
29308
29309
29310 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29311 PyObject *resultobj = 0;
29312 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29313 wxPoint *arg2 = 0 ;
29314 void *argp1 = 0 ;
29315 int res1 = 0 ;
29316 wxPoint temp2 ;
29317 PyObject * obj0 = 0 ;
29318 PyObject * obj1 = 0 ;
29319 char * kwnames[] = {
29320 (char *) "self",(char *) "pos", NULL
29321 };
29322
29323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29325 if (!SWIG_IsOK(res1)) {
29326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29327 }
29328 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29329 {
29330 arg2 = &temp2;
29331 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29332 }
29333 {
29334 PyThreadState* __tstate = wxPyBeginAllowThreads();
29335 (arg1)->SetPosition((wxPoint const &)*arg2);
29336 wxPyEndAllowThreads(__tstate);
29337 if (PyErr_Occurred()) SWIG_fail;
29338 }
29339 resultobj = SWIG_Py_Void();
29340 return resultobj;
29341 fail:
29342 return NULL;
29343 }
29344
29345
29346 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29347 PyObject *obj;
29348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29349 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29350 return SWIG_Py_Void();
29351 }
29352
29353 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29354 return SWIG_Python_InitShadowInstance(args);
29355 }
29356
29357 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29358 PyObject *resultobj = 0;
29359 wxIdleEvent *result = 0 ;
29360
29361 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29362 {
29363 PyThreadState* __tstate = wxPyBeginAllowThreads();
29364 result = (wxIdleEvent *)new wxIdleEvent();
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29376 PyObject *resultobj = 0;
29377 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29378 bool arg2 = (bool) true ;
29379 void *argp1 = 0 ;
29380 int res1 = 0 ;
29381 bool val2 ;
29382 int ecode2 = 0 ;
29383 PyObject * obj0 = 0 ;
29384 PyObject * obj1 = 0 ;
29385 char * kwnames[] = {
29386 (char *) "self",(char *) "needMore", NULL
29387 };
29388
29389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29391 if (!SWIG_IsOK(res1)) {
29392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29393 }
29394 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29395 if (obj1) {
29396 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29397 if (!SWIG_IsOK(ecode2)) {
29398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29399 }
29400 arg2 = static_cast< bool >(val2);
29401 }
29402 {
29403 PyThreadState* __tstate = wxPyBeginAllowThreads();
29404 (arg1)->RequestMore(arg2);
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 resultobj = SWIG_Py_Void();
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29418 bool result;
29419 void *argp1 = 0 ;
29420 int res1 = 0 ;
29421 PyObject *swig_obj[1] ;
29422
29423 if (!args) SWIG_fail;
29424 swig_obj[0] = args;
29425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29426 if (!SWIG_IsOK(res1)) {
29427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29428 }
29429 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 {
29437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29438 }
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = 0;
29447 wxIdleMode arg1 ;
29448 int val1 ;
29449 int ecode1 = 0 ;
29450 PyObject * obj0 = 0 ;
29451 char * kwnames[] = {
29452 (char *) "mode", NULL
29453 };
29454
29455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29456 ecode1 = SWIG_AsVal_int(obj0, &val1);
29457 if (!SWIG_IsOK(ecode1)) {
29458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29459 }
29460 arg1 = static_cast< wxIdleMode >(val1);
29461 {
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 wxIdleEvent::SetMode(arg1);
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 resultobj = SWIG_Py_Void();
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29475 PyObject *resultobj = 0;
29476 wxIdleMode result;
29477
29478 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29479 {
29480 PyThreadState* __tstate = wxPyBeginAllowThreads();
29481 result = (wxIdleMode)wxIdleEvent::GetMode();
29482 wxPyEndAllowThreads(__tstate);
29483 if (PyErr_Occurred()) SWIG_fail;
29484 }
29485 resultobj = SWIG_From_int(static_cast< int >(result));
29486 return resultobj;
29487 fail:
29488 return NULL;
29489 }
29490
29491
29492 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29493 PyObject *resultobj = 0;
29494 wxWindow *arg1 = (wxWindow *) 0 ;
29495 bool result;
29496 void *argp1 = 0 ;
29497 int res1 = 0 ;
29498 PyObject * obj0 = 0 ;
29499 char * kwnames[] = {
29500 (char *) "win", NULL
29501 };
29502
29503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29505 if (!SWIG_IsOK(res1)) {
29506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29507 }
29508 arg1 = reinterpret_cast< wxWindow * >(argp1);
29509 {
29510 PyThreadState* __tstate = wxPyBeginAllowThreads();
29511 result = (bool)wxIdleEvent::CanSend(arg1);
29512 wxPyEndAllowThreads(__tstate);
29513 if (PyErr_Occurred()) SWIG_fail;
29514 }
29515 {
29516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29517 }
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29525 PyObject *obj;
29526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29527 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29528 return SWIG_Py_Void();
29529 }
29530
29531 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29532 return SWIG_Python_InitShadowInstance(args);
29533 }
29534
29535 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29536 PyObject *resultobj = 0;
29537 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29538 int arg2 = (int) 0 ;
29539 wxClipboardTextEvent *result = 0 ;
29540 int val1 ;
29541 int ecode1 = 0 ;
29542 int val2 ;
29543 int ecode2 = 0 ;
29544 PyObject * obj0 = 0 ;
29545 PyObject * obj1 = 0 ;
29546 char * kwnames[] = {
29547 (char *) "type",(char *) "winid", NULL
29548 };
29549
29550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29551 if (obj0) {
29552 ecode1 = SWIG_AsVal_int(obj0, &val1);
29553 if (!SWIG_IsOK(ecode1)) {
29554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29555 }
29556 arg1 = static_cast< wxEventType >(val1);
29557 }
29558 if (obj1) {
29559 ecode2 = SWIG_AsVal_int(obj1, &val2);
29560 if (!SWIG_IsOK(ecode2)) {
29561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29562 }
29563 arg2 = static_cast< int >(val2);
29564 }
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29568 wxPyEndAllowThreads(__tstate);
29569 if (PyErr_Occurred()) SWIG_fail;
29570 }
29571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29572 return resultobj;
29573 fail:
29574 return NULL;
29575 }
29576
29577
29578 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29579 PyObject *obj;
29580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29581 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29582 return SWIG_Py_Void();
29583 }
29584
29585 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29586 return SWIG_Python_InitShadowInstance(args);
29587 }
29588
29589 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj = 0;
29591 int arg1 = (int) 0 ;
29592 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29593 wxPyEvent *result = 0 ;
29594 int val1 ;
29595 int ecode1 = 0 ;
29596 int val2 ;
29597 int ecode2 = 0 ;
29598 PyObject * obj0 = 0 ;
29599 PyObject * obj1 = 0 ;
29600 char * kwnames[] = {
29601 (char *) "winid",(char *) "eventType", NULL
29602 };
29603
29604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29605 if (obj0) {
29606 ecode1 = SWIG_AsVal_int(obj0, &val1);
29607 if (!SWIG_IsOK(ecode1)) {
29608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29609 }
29610 arg1 = static_cast< int >(val1);
29611 }
29612 if (obj1) {
29613 ecode2 = SWIG_AsVal_int(obj1, &val2);
29614 if (!SWIG_IsOK(ecode2)) {
29615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29616 }
29617 arg2 = static_cast< wxEventType >(val2);
29618 }
29619 {
29620 PyThreadState* __tstate = wxPyBeginAllowThreads();
29621 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29633 PyObject *resultobj = 0;
29634 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29635 void *argp1 = 0 ;
29636 int res1 = 0 ;
29637 PyObject *swig_obj[1] ;
29638
29639 if (!args) SWIG_fail;
29640 swig_obj[0] = args;
29641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29642 if (!SWIG_IsOK(res1)) {
29643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29644 }
29645 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 delete arg1;
29649
29650 wxPyEndAllowThreads(__tstate);
29651 if (PyErr_Occurred()) SWIG_fail;
29652 }
29653 resultobj = SWIG_Py_Void();
29654 return resultobj;
29655 fail:
29656 return NULL;
29657 }
29658
29659
29660 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29661 PyObject *resultobj = 0;
29662 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29663 PyObject *arg2 = (PyObject *) 0 ;
29664 void *argp1 = 0 ;
29665 int res1 = 0 ;
29666 PyObject * obj0 = 0 ;
29667 PyObject * obj1 = 0 ;
29668 char * kwnames[] = {
29669 (char *) "self",(char *) "self", NULL
29670 };
29671
29672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29674 if (!SWIG_IsOK(res1)) {
29675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29676 }
29677 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29678 arg2 = obj1;
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 (arg1)->SetSelf(arg2);
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 resultobj = SWIG_Py_Void();
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29693 PyObject *resultobj = 0;
29694 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29695 PyObject *result = 0 ;
29696 void *argp1 = 0 ;
29697 int res1 = 0 ;
29698 PyObject *swig_obj[1] ;
29699
29700 if (!args) SWIG_fail;
29701 swig_obj[0] = args;
29702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29703 if (!SWIG_IsOK(res1)) {
29704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29705 }
29706 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29707 {
29708 PyThreadState* __tstate = wxPyBeginAllowThreads();
29709 result = (PyObject *)(arg1)->GetSelf();
29710 wxPyEndAllowThreads(__tstate);
29711 if (PyErr_Occurred()) SWIG_fail;
29712 }
29713 resultobj = result;
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29721 PyObject *obj;
29722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29723 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29724 return SWIG_Py_Void();
29725 }
29726
29727 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29728 return SWIG_Python_InitShadowInstance(args);
29729 }
29730
29731 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj = 0;
29733 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29734 int arg2 = (int) 0 ;
29735 wxPyCommandEvent *result = 0 ;
29736 int val1 ;
29737 int ecode1 = 0 ;
29738 int val2 ;
29739 int ecode2 = 0 ;
29740 PyObject * obj0 = 0 ;
29741 PyObject * obj1 = 0 ;
29742 char * kwnames[] = {
29743 (char *) "eventType",(char *) "id", NULL
29744 };
29745
29746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29747 if (obj0) {
29748 ecode1 = SWIG_AsVal_int(obj0, &val1);
29749 if (!SWIG_IsOK(ecode1)) {
29750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29751 }
29752 arg1 = static_cast< wxEventType >(val1);
29753 }
29754 if (obj1) {
29755 ecode2 = SWIG_AsVal_int(obj1, &val2);
29756 if (!SWIG_IsOK(ecode2)) {
29757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29758 }
29759 arg2 = static_cast< int >(val2);
29760 }
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29764 wxPyEndAllowThreads(__tstate);
29765 if (PyErr_Occurred()) SWIG_fail;
29766 }
29767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29775 PyObject *resultobj = 0;
29776 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29777 void *argp1 = 0 ;
29778 int res1 = 0 ;
29779 PyObject *swig_obj[1] ;
29780
29781 if (!args) SWIG_fail;
29782 swig_obj[0] = args;
29783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29784 if (!SWIG_IsOK(res1)) {
29785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29786 }
29787 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 delete arg1;
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 resultobj = SWIG_Py_Void();
29796 return resultobj;
29797 fail:
29798 return NULL;
29799 }
29800
29801
29802 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29803 PyObject *resultobj = 0;
29804 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29805 PyObject *arg2 = (PyObject *) 0 ;
29806 void *argp1 = 0 ;
29807 int res1 = 0 ;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char * kwnames[] = {
29811 (char *) "self",(char *) "self", NULL
29812 };
29813
29814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29816 if (!SWIG_IsOK(res1)) {
29817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29818 }
29819 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29820 arg2 = obj1;
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 (arg1)->SetSelf(arg2);
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 resultobj = SWIG_Py_Void();
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29835 PyObject *resultobj = 0;
29836 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29837 PyObject *result = 0 ;
29838 void *argp1 = 0 ;
29839 int res1 = 0 ;
29840 PyObject *swig_obj[1] ;
29841
29842 if (!args) SWIG_fail;
29843 swig_obj[0] = args;
29844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29845 if (!SWIG_IsOK(res1)) {
29846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29847 }
29848 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 result = (PyObject *)(arg1)->GetSelf();
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 resultobj = result;
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29863 PyObject *obj;
29864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29865 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29866 return SWIG_Py_Void();
29867 }
29868
29869 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29870 return SWIG_Python_InitShadowInstance(args);
29871 }
29872
29873 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29874 PyObject *resultobj = 0;
29875 wxWindow *arg1 = (wxWindow *) 0 ;
29876 wxDateTime *arg2 = 0 ;
29877 wxEventType arg3 ;
29878 wxDateEvent *result = 0 ;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 void *argp2 = 0 ;
29882 int res2 = 0 ;
29883 int val3 ;
29884 int ecode3 = 0 ;
29885 PyObject * obj0 = 0 ;
29886 PyObject * obj1 = 0 ;
29887 PyObject * obj2 = 0 ;
29888 char * kwnames[] = {
29889 (char *) "win",(char *) "dt",(char *) "type", NULL
29890 };
29891
29892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29894 if (!SWIG_IsOK(res1)) {
29895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29896 }
29897 arg1 = reinterpret_cast< wxWindow * >(argp1);
29898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29899 if (!SWIG_IsOK(res2)) {
29900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29901 }
29902 if (!argp2) {
29903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29904 }
29905 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29906 ecode3 = SWIG_AsVal_int(obj2, &val3);
29907 if (!SWIG_IsOK(ecode3)) {
29908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29909 }
29910 arg3 = static_cast< wxEventType >(val3);
29911 {
29912 PyThreadState* __tstate = wxPyBeginAllowThreads();
29913 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29914 wxPyEndAllowThreads(__tstate);
29915 if (PyErr_Occurred()) SWIG_fail;
29916 }
29917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29925 PyObject *resultobj = 0;
29926 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29927 wxDateTime *result = 0 ;
29928 void *argp1 = 0 ;
29929 int res1 = 0 ;
29930 PyObject *swig_obj[1] ;
29931
29932 if (!args) SWIG_fail;
29933 swig_obj[0] = args;
29934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29935 if (!SWIG_IsOK(res1)) {
29936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29937 }
29938 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 {
29942 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29943 result = (wxDateTime *) &_result_ref;
29944 }
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29956 PyObject *resultobj = 0;
29957 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29958 wxDateTime *arg2 = 0 ;
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 void *argp2 = 0 ;
29962 int res2 = 0 ;
29963 PyObject * obj0 = 0 ;
29964 PyObject * obj1 = 0 ;
29965 char * kwnames[] = {
29966 (char *) "self",(char *) "date", NULL
29967 };
29968
29969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29971 if (!SWIG_IsOK(res1)) {
29972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29973 }
29974 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29976 if (!SWIG_IsOK(res2)) {
29977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29978 }
29979 if (!argp2) {
29980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29981 }
29982 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 (arg1)->SetDate((wxDateTime const &)*arg2);
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 resultobj = SWIG_Py_Void();
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29997 PyObject *obj;
29998 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29999 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30000 return SWIG_Py_Void();
30001 }
30002
30003 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30004 return SWIG_Python_InitShadowInstance(args);
30005 }
30006
30007 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30008 PyObject *resultobj = 0;
30009 wxWindow *arg1 = (wxWindow *) 0 ;
30010 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30011 wxEventBlocker *result = 0 ;
30012 void *argp1 = 0 ;
30013 int res1 = 0 ;
30014 int val2 ;
30015 int ecode2 = 0 ;
30016 PyObject * obj0 = 0 ;
30017 PyObject * obj1 = 0 ;
30018 char * kwnames[] = {
30019 (char *) "win",(char *) "type", NULL
30020 };
30021
30022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30024 if (!SWIG_IsOK(res1)) {
30025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30026 }
30027 arg1 = reinterpret_cast< wxWindow * >(argp1);
30028 if (obj1) {
30029 ecode2 = SWIG_AsVal_int(obj1, &val2);
30030 if (!SWIG_IsOK(ecode2)) {
30031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30032 }
30033 arg2 = static_cast< wxEventType >(val2);
30034 }
30035 {
30036 PyThreadState* __tstate = wxPyBeginAllowThreads();
30037 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30038 wxPyEndAllowThreads(__tstate);
30039 if (PyErr_Occurred()) SWIG_fail;
30040 }
30041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30042 return resultobj;
30043 fail:
30044 return NULL;
30045 }
30046
30047
30048 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30049 PyObject *resultobj = 0;
30050 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30051 void *argp1 = 0 ;
30052 int res1 = 0 ;
30053 PyObject *swig_obj[1] ;
30054
30055 if (!args) SWIG_fail;
30056 swig_obj[0] = args;
30057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30058 if (!SWIG_IsOK(res1)) {
30059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30060 }
30061 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 delete arg1;
30065
30066 wxPyEndAllowThreads(__tstate);
30067 if (PyErr_Occurred()) SWIG_fail;
30068 }
30069 resultobj = SWIG_Py_Void();
30070 return resultobj;
30071 fail:
30072 return NULL;
30073 }
30074
30075
30076 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30077 PyObject *resultobj = 0;
30078 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30079 wxEventType arg2 ;
30080 void *argp1 = 0 ;
30081 int res1 = 0 ;
30082 int val2 ;
30083 int ecode2 = 0 ;
30084 PyObject * obj0 = 0 ;
30085 PyObject * obj1 = 0 ;
30086 char * kwnames[] = {
30087 (char *) "self",(char *) "type", NULL
30088 };
30089
30090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30092 if (!SWIG_IsOK(res1)) {
30093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30094 }
30095 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30096 ecode2 = SWIG_AsVal_int(obj1, &val2);
30097 if (!SWIG_IsOK(ecode2)) {
30098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30099 }
30100 arg2 = static_cast< wxEventType >(val2);
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 (arg1)->Block(arg2);
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 resultobj = SWIG_Py_Void();
30108 return resultobj;
30109 fail:
30110 return NULL;
30111 }
30112
30113
30114 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30115 PyObject *obj;
30116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30117 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30118 return SWIG_Py_Void();
30119 }
30120
30121 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30122 return SWIG_Python_InitShadowInstance(args);
30123 }
30124
30125 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30126 PyObject *resultobj = 0;
30127 wxPyApp *result = 0 ;
30128
30129 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 result = (wxPyApp *)new_wxPyApp();
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30144 PyObject *resultobj = 0;
30145 wxPyApp *arg1 = (wxPyApp *) 0 ;
30146 void *argp1 = 0 ;
30147 int res1 = 0 ;
30148 PyObject *swig_obj[1] ;
30149
30150 if (!args) SWIG_fail;
30151 swig_obj[0] = args;
30152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30153 if (!SWIG_IsOK(res1)) {
30154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30155 }
30156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 delete arg1;
30160
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 resultobj = SWIG_Py_Void();
30165 return resultobj;
30166 fail:
30167 return NULL;
30168 }
30169
30170
30171 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30172 PyObject *resultobj = 0;
30173 wxPyApp *arg1 = (wxPyApp *) 0 ;
30174 PyObject *arg2 = (PyObject *) 0 ;
30175 PyObject *arg3 = (PyObject *) 0 ;
30176 bool arg4 = (bool) false ;
30177 void *argp1 = 0 ;
30178 int res1 = 0 ;
30179 bool val4 ;
30180 int ecode4 = 0 ;
30181 PyObject * obj0 = 0 ;
30182 PyObject * obj1 = 0 ;
30183 PyObject * obj2 = 0 ;
30184 PyObject * obj3 = 0 ;
30185 char * kwnames[] = {
30186 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30187 };
30188
30189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30191 if (!SWIG_IsOK(res1)) {
30192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30193 }
30194 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30195 arg2 = obj1;
30196 arg3 = obj2;
30197 if (obj3) {
30198 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30199 if (!SWIG_IsOK(ecode4)) {
30200 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30201 }
30202 arg4 = static_cast< bool >(val4);
30203 }
30204 {
30205 PyThreadState* __tstate = wxPyBeginAllowThreads();
30206 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30207 wxPyEndAllowThreads(__tstate);
30208 if (PyErr_Occurred()) SWIG_fail;
30209 }
30210 resultobj = SWIG_Py_Void();
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30218 PyObject *resultobj = 0;
30219 wxPyApp *arg1 = (wxPyApp *) 0 ;
30220 wxString result;
30221 void *argp1 = 0 ;
30222 int res1 = 0 ;
30223 PyObject *swig_obj[1] ;
30224
30225 if (!args) SWIG_fail;
30226 swig_obj[0] = args;
30227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30228 if (!SWIG_IsOK(res1)) {
30229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30230 }
30231 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 result = ((wxPyApp const *)arg1)->GetAppName();
30235 wxPyEndAllowThreads(__tstate);
30236 if (PyErr_Occurred()) SWIG_fail;
30237 }
30238 {
30239 #if wxUSE_UNICODE
30240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30241 #else
30242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30243 #endif
30244 }
30245 return resultobj;
30246 fail:
30247 return NULL;
30248 }
30249
30250
30251 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30252 PyObject *resultobj = 0;
30253 wxPyApp *arg1 = (wxPyApp *) 0 ;
30254 wxString *arg2 = 0 ;
30255 void *argp1 = 0 ;
30256 int res1 = 0 ;
30257 bool temp2 = false ;
30258 PyObject * obj0 = 0 ;
30259 PyObject * obj1 = 0 ;
30260 char * kwnames[] = {
30261 (char *) "self",(char *) "name", NULL
30262 };
30263
30264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30266 if (!SWIG_IsOK(res1)) {
30267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30268 }
30269 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30270 {
30271 arg2 = wxString_in_helper(obj1);
30272 if (arg2 == NULL) SWIG_fail;
30273 temp2 = true;
30274 }
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 (arg1)->SetAppName((wxString const &)*arg2);
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 resultobj = SWIG_Py_Void();
30282 {
30283 if (temp2)
30284 delete arg2;
30285 }
30286 return resultobj;
30287 fail:
30288 {
30289 if (temp2)
30290 delete arg2;
30291 }
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30297 PyObject *resultobj = 0;
30298 wxPyApp *arg1 = (wxPyApp *) 0 ;
30299 wxString result;
30300 void *argp1 = 0 ;
30301 int res1 = 0 ;
30302 PyObject *swig_obj[1] ;
30303
30304 if (!args) SWIG_fail;
30305 swig_obj[0] = args;
30306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30307 if (!SWIG_IsOK(res1)) {
30308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30309 }
30310 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 result = ((wxPyApp const *)arg1)->GetClassName();
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 {
30318 #if wxUSE_UNICODE
30319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30320 #else
30321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30322 #endif
30323 }
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj = 0;
30332 wxPyApp *arg1 = (wxPyApp *) 0 ;
30333 wxString *arg2 = 0 ;
30334 void *argp1 = 0 ;
30335 int res1 = 0 ;
30336 bool temp2 = false ;
30337 PyObject * obj0 = 0 ;
30338 PyObject * obj1 = 0 ;
30339 char * kwnames[] = {
30340 (char *) "self",(char *) "name", NULL
30341 };
30342
30343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30345 if (!SWIG_IsOK(res1)) {
30346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30347 }
30348 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30349 {
30350 arg2 = wxString_in_helper(obj1);
30351 if (arg2 == NULL) SWIG_fail;
30352 temp2 = true;
30353 }
30354 {
30355 PyThreadState* __tstate = wxPyBeginAllowThreads();
30356 (arg1)->SetClassName((wxString const &)*arg2);
30357 wxPyEndAllowThreads(__tstate);
30358 if (PyErr_Occurred()) SWIG_fail;
30359 }
30360 resultobj = SWIG_Py_Void();
30361 {
30362 if (temp2)
30363 delete arg2;
30364 }
30365 return resultobj;
30366 fail:
30367 {
30368 if (temp2)
30369 delete arg2;
30370 }
30371 return NULL;
30372 }
30373
30374
30375 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30376 PyObject *resultobj = 0;
30377 wxPyApp *arg1 = (wxPyApp *) 0 ;
30378 wxString *result = 0 ;
30379 void *argp1 = 0 ;
30380 int res1 = 0 ;
30381 PyObject *swig_obj[1] ;
30382
30383 if (!args) SWIG_fail;
30384 swig_obj[0] = args;
30385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30386 if (!SWIG_IsOK(res1)) {
30387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30388 }
30389 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30390 {
30391 PyThreadState* __tstate = wxPyBeginAllowThreads();
30392 {
30393 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30394 result = (wxString *) &_result_ref;
30395 }
30396 wxPyEndAllowThreads(__tstate);
30397 if (PyErr_Occurred()) SWIG_fail;
30398 }
30399 {
30400 #if wxUSE_UNICODE
30401 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30402 #else
30403 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30404 #endif
30405 }
30406 return resultobj;
30407 fail:
30408 return NULL;
30409 }
30410
30411
30412 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30413 PyObject *resultobj = 0;
30414 wxPyApp *arg1 = (wxPyApp *) 0 ;
30415 wxString *arg2 = 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 bool temp2 = false ;
30419 PyObject * obj0 = 0 ;
30420 PyObject * obj1 = 0 ;
30421 char * kwnames[] = {
30422 (char *) "self",(char *) "name", NULL
30423 };
30424
30425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30427 if (!SWIG_IsOK(res1)) {
30428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30429 }
30430 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30431 {
30432 arg2 = wxString_in_helper(obj1);
30433 if (arg2 == NULL) SWIG_fail;
30434 temp2 = true;
30435 }
30436 {
30437 PyThreadState* __tstate = wxPyBeginAllowThreads();
30438 (arg1)->SetVendorName((wxString const &)*arg2);
30439 wxPyEndAllowThreads(__tstate);
30440 if (PyErr_Occurred()) SWIG_fail;
30441 }
30442 resultobj = SWIG_Py_Void();
30443 {
30444 if (temp2)
30445 delete arg2;
30446 }
30447 return resultobj;
30448 fail:
30449 {
30450 if (temp2)
30451 delete arg2;
30452 }
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30458 PyObject *resultobj = 0;
30459 wxPyApp *arg1 = (wxPyApp *) 0 ;
30460 wxAppTraits *result = 0 ;
30461 void *argp1 = 0 ;
30462 int res1 = 0 ;
30463 PyObject *swig_obj[1] ;
30464
30465 if (!args) SWIG_fail;
30466 swig_obj[0] = args;
30467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30468 if (!SWIG_IsOK(res1)) {
30469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30470 }
30471 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30472 {
30473 PyThreadState* __tstate = wxPyBeginAllowThreads();
30474 result = (wxAppTraits *)(arg1)->GetTraits();
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30486 PyObject *resultobj = 0;
30487 wxPyApp *arg1 = (wxPyApp *) 0 ;
30488 void *argp1 = 0 ;
30489 int res1 = 0 ;
30490 PyObject *swig_obj[1] ;
30491
30492 if (!args) SWIG_fail;
30493 swig_obj[0] = args;
30494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30495 if (!SWIG_IsOK(res1)) {
30496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30497 }
30498 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30499 {
30500 PyThreadState* __tstate = wxPyBeginAllowThreads();
30501 (arg1)->ProcessPendingEvents();
30502 wxPyEndAllowThreads(__tstate);
30503 if (PyErr_Occurred()) SWIG_fail;
30504 }
30505 resultobj = SWIG_Py_Void();
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj = 0;
30514 wxPyApp *arg1 = (wxPyApp *) 0 ;
30515 bool arg2 = (bool) false ;
30516 bool result;
30517 void *argp1 = 0 ;
30518 int res1 = 0 ;
30519 bool val2 ;
30520 int ecode2 = 0 ;
30521 PyObject * obj0 = 0 ;
30522 PyObject * obj1 = 0 ;
30523 char * kwnames[] = {
30524 (char *) "self",(char *) "onlyIfNeeded", NULL
30525 };
30526
30527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30529 if (!SWIG_IsOK(res1)) {
30530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30531 }
30532 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30533 if (obj1) {
30534 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30535 if (!SWIG_IsOK(ecode2)) {
30536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30537 }
30538 arg2 = static_cast< bool >(val2);
30539 }
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = (bool)(arg1)->Yield(arg2);
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 {
30547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30548 }
30549 return resultobj;
30550 fail:
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxPyApp *arg1 = (wxPyApp *) 0 ;
30558 void *argp1 = 0 ;
30559 int res1 = 0 ;
30560 PyObject *swig_obj[1] ;
30561
30562 if (!args) SWIG_fail;
30563 swig_obj[0] = args;
30564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30567 }
30568 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 (arg1)->WakeUpIdle();
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 resultobj = SWIG_Py_Void();
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30583 PyObject *resultobj = 0;
30584 bool result;
30585
30586 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 result = (bool)wxPyApp::IsMainLoopRunning();
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 {
30594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30595 }
30596 return resultobj;
30597 fail:
30598 return NULL;
30599 }
30600
30601
30602 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30603 PyObject *resultobj = 0;
30604 wxPyApp *arg1 = (wxPyApp *) 0 ;
30605 int result;
30606 void *argp1 = 0 ;
30607 int res1 = 0 ;
30608 PyObject *swig_obj[1] ;
30609
30610 if (!args) SWIG_fail;
30611 swig_obj[0] = args;
30612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30613 if (!SWIG_IsOK(res1)) {
30614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30615 }
30616 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30617 {
30618 PyThreadState* __tstate = wxPyBeginAllowThreads();
30619 result = (int)(arg1)->MainLoop();
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 resultobj = SWIG_From_int(static_cast< int >(result));
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30631 PyObject *resultobj = 0;
30632 wxPyApp *arg1 = (wxPyApp *) 0 ;
30633 void *argp1 = 0 ;
30634 int res1 = 0 ;
30635 PyObject *swig_obj[1] ;
30636
30637 if (!args) SWIG_fail;
30638 swig_obj[0] = args;
30639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30640 if (!SWIG_IsOK(res1)) {
30641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30642 }
30643 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 (arg1)->Exit();
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 resultobj = SWIG_Py_Void();
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30658 PyObject *resultobj = 0;
30659 wxPyApp *arg1 = (wxPyApp *) 0 ;
30660 wxLayoutDirection result;
30661 void *argp1 = 0 ;
30662 int res1 = 0 ;
30663 PyObject *swig_obj[1] ;
30664
30665 if (!args) SWIG_fail;
30666 swig_obj[0] = args;
30667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30668 if (!SWIG_IsOK(res1)) {
30669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30670 }
30671 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 resultobj = SWIG_From_int(static_cast< int >(result));
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30686 PyObject *resultobj = 0;
30687 wxPyApp *arg1 = (wxPyApp *) 0 ;
30688 void *argp1 = 0 ;
30689 int res1 = 0 ;
30690 PyObject *swig_obj[1] ;
30691
30692 if (!args) SWIG_fail;
30693 swig_obj[0] = args;
30694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30695 if (!SWIG_IsOK(res1)) {
30696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30697 }
30698 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30699 {
30700 PyThreadState* __tstate = wxPyBeginAllowThreads();
30701 (arg1)->ExitMainLoop();
30702 wxPyEndAllowThreads(__tstate);
30703 if (PyErr_Occurred()) SWIG_fail;
30704 }
30705 resultobj = SWIG_Py_Void();
30706 return resultobj;
30707 fail:
30708 return NULL;
30709 }
30710
30711
30712 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30713 PyObject *resultobj = 0;
30714 wxPyApp *arg1 = (wxPyApp *) 0 ;
30715 bool result;
30716 void *argp1 = 0 ;
30717 int res1 = 0 ;
30718 PyObject *swig_obj[1] ;
30719
30720 if (!args) SWIG_fail;
30721 swig_obj[0] = args;
30722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30723 if (!SWIG_IsOK(res1)) {
30724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30725 }
30726 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 result = (bool)(arg1)->Pending();
30730 wxPyEndAllowThreads(__tstate);
30731 if (PyErr_Occurred()) SWIG_fail;
30732 }
30733 {
30734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30735 }
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30743 PyObject *resultobj = 0;
30744 wxPyApp *arg1 = (wxPyApp *) 0 ;
30745 bool result;
30746 void *argp1 = 0 ;
30747 int res1 = 0 ;
30748 PyObject *swig_obj[1] ;
30749
30750 if (!args) SWIG_fail;
30751 swig_obj[0] = args;
30752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30753 if (!SWIG_IsOK(res1)) {
30754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30755 }
30756 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (bool)(arg1)->Dispatch();
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 {
30764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30765 }
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxPyApp *arg1 = (wxPyApp *) 0 ;
30775 bool result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 PyObject *swig_obj[1] ;
30779
30780 if (!args) SWIG_fail;
30781 swig_obj[0] = args;
30782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30783 if (!SWIG_IsOK(res1)) {
30784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30785 }
30786 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = (bool)(arg1)->ProcessIdle();
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 {
30794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30795 }
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30803 PyObject *resultobj = 0;
30804 wxPyApp *arg1 = (wxPyApp *) 0 ;
30805 wxWindow *arg2 = (wxWindow *) 0 ;
30806 wxIdleEvent *arg3 = 0 ;
30807 bool result;
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 void *argp2 = 0 ;
30811 int res2 = 0 ;
30812 void *argp3 = 0 ;
30813 int res3 = 0 ;
30814 PyObject * obj0 = 0 ;
30815 PyObject * obj1 = 0 ;
30816 PyObject * obj2 = 0 ;
30817 char * kwnames[] = {
30818 (char *) "self",(char *) "win",(char *) "event", NULL
30819 };
30820
30821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30823 if (!SWIG_IsOK(res1)) {
30824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30825 }
30826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30828 if (!SWIG_IsOK(res2)) {
30829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30830 }
30831 arg2 = reinterpret_cast< wxWindow * >(argp2);
30832 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30833 if (!SWIG_IsOK(res3)) {
30834 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30835 }
30836 if (!argp3) {
30837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30838 }
30839 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30840 {
30841 PyThreadState* __tstate = wxPyBeginAllowThreads();
30842 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 {
30847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxPyApp *arg1 = (wxPyApp *) 0 ;
30858 bool result;
30859 void *argp1 = 0 ;
30860 int res1 = 0 ;
30861 PyObject *swig_obj[1] ;
30862
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 result = (bool)((wxPyApp const *)arg1)->IsActive();
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 {
30877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30878 }
30879 return resultobj;
30880 fail:
30881 return NULL;
30882 }
30883
30884
30885 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30886 PyObject *resultobj = 0;
30887 wxPyApp *arg1 = (wxPyApp *) 0 ;
30888 wxWindow *arg2 = (wxWindow *) 0 ;
30889 void *argp1 = 0 ;
30890 int res1 = 0 ;
30891 void *argp2 = 0 ;
30892 int res2 = 0 ;
30893 PyObject * obj0 = 0 ;
30894 PyObject * obj1 = 0 ;
30895 char * kwnames[] = {
30896 (char *) "self",(char *) "win", NULL
30897 };
30898
30899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30901 if (!SWIG_IsOK(res1)) {
30902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30903 }
30904 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30905 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30906 if (!SWIG_IsOK(res2)) {
30907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30908 }
30909 arg2 = reinterpret_cast< wxWindow * >(argp2);
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 (arg1)->SetTopWindow(arg2);
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 resultobj = SWIG_Py_Void();
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30924 PyObject *resultobj = 0;
30925 wxPyApp *arg1 = (wxPyApp *) 0 ;
30926 wxWindow *result = 0 ;
30927 void *argp1 = 0 ;
30928 int res1 = 0 ;
30929 PyObject *swig_obj[1] ;
30930
30931 if (!args) SWIG_fail;
30932 swig_obj[0] = args;
30933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30934 if (!SWIG_IsOK(res1)) {
30935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30936 }
30937 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 {
30945 resultobj = wxPyMake_wxObject(result, (bool)0);
30946 }
30947 return resultobj;
30948 fail:
30949 return NULL;
30950 }
30951
30952
30953 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30954 PyObject *resultobj = 0;
30955 wxPyApp *arg1 = (wxPyApp *) 0 ;
30956 bool arg2 ;
30957 void *argp1 = 0 ;
30958 int res1 = 0 ;
30959 bool val2 ;
30960 int ecode2 = 0 ;
30961 PyObject * obj0 = 0 ;
30962 PyObject * obj1 = 0 ;
30963 char * kwnames[] = {
30964 (char *) "self",(char *) "flag", NULL
30965 };
30966
30967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30969 if (!SWIG_IsOK(res1)) {
30970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30971 }
30972 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30973 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30974 if (!SWIG_IsOK(ecode2)) {
30975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30976 }
30977 arg2 = static_cast< bool >(val2);
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 (arg1)->SetExitOnFrameDelete(arg2);
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 resultobj = SWIG_Py_Void();
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30992 PyObject *resultobj = 0;
30993 wxPyApp *arg1 = (wxPyApp *) 0 ;
30994 bool result;
30995 void *argp1 = 0 ;
30996 int res1 = 0 ;
30997 PyObject *swig_obj[1] ;
30998
30999 if (!args) SWIG_fail;
31000 swig_obj[0] = args;
31001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31002 if (!SWIG_IsOK(res1)) {
31003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31004 }
31005 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 {
31013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31014 }
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31022 PyObject *resultobj = 0;
31023 wxPyApp *arg1 = (wxPyApp *) 0 ;
31024 bool arg2 ;
31025 bool arg3 = (bool) false ;
31026 void *argp1 = 0 ;
31027 int res1 = 0 ;
31028 bool val2 ;
31029 int ecode2 = 0 ;
31030 bool val3 ;
31031 int ecode3 = 0 ;
31032 PyObject * obj0 = 0 ;
31033 PyObject * obj1 = 0 ;
31034 PyObject * obj2 = 0 ;
31035 char * kwnames[] = {
31036 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31037 };
31038
31039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31041 if (!SWIG_IsOK(res1)) {
31042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31043 }
31044 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31045 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31046 if (!SWIG_IsOK(ecode2)) {
31047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31048 }
31049 arg2 = static_cast< bool >(val2);
31050 if (obj2) {
31051 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31052 if (!SWIG_IsOK(ecode3)) {
31053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31054 }
31055 arg3 = static_cast< bool >(val3);
31056 }
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 (arg1)->SetUseBestVisual(arg2,arg3);
31060 wxPyEndAllowThreads(__tstate);
31061 if (PyErr_Occurred()) SWIG_fail;
31062 }
31063 resultobj = SWIG_Py_Void();
31064 return resultobj;
31065 fail:
31066 return NULL;
31067 }
31068
31069
31070 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31071 PyObject *resultobj = 0;
31072 wxPyApp *arg1 = (wxPyApp *) 0 ;
31073 bool result;
31074 void *argp1 = 0 ;
31075 int res1 = 0 ;
31076 PyObject *swig_obj[1] ;
31077
31078 if (!args) SWIG_fail;
31079 swig_obj[0] = args;
31080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31081 if (!SWIG_IsOK(res1)) {
31082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31083 }
31084 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31085 {
31086 PyThreadState* __tstate = wxPyBeginAllowThreads();
31087 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31088 wxPyEndAllowThreads(__tstate);
31089 if (PyErr_Occurred()) SWIG_fail;
31090 }
31091 {
31092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31093 }
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj = 0;
31102 wxPyApp *arg1 = (wxPyApp *) 0 ;
31103 int arg2 ;
31104 void *argp1 = 0 ;
31105 int res1 = 0 ;
31106 int val2 ;
31107 int ecode2 = 0 ;
31108 PyObject * obj0 = 0 ;
31109 PyObject * obj1 = 0 ;
31110 char * kwnames[] = {
31111 (char *) "self",(char *) "mode", NULL
31112 };
31113
31114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31116 if (!SWIG_IsOK(res1)) {
31117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31118 }
31119 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31120 ecode2 = SWIG_AsVal_int(obj1, &val2);
31121 if (!SWIG_IsOK(ecode2)) {
31122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31123 }
31124 arg2 = static_cast< int >(val2);
31125 {
31126 PyThreadState* __tstate = wxPyBeginAllowThreads();
31127 (arg1)->SetPrintMode(arg2);
31128 wxPyEndAllowThreads(__tstate);
31129 if (PyErr_Occurred()) SWIG_fail;
31130 }
31131 resultobj = SWIG_Py_Void();
31132 return resultobj;
31133 fail:
31134 return NULL;
31135 }
31136
31137
31138 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31139 PyObject *resultobj = 0;
31140 wxPyApp *arg1 = (wxPyApp *) 0 ;
31141 int result;
31142 void *argp1 = 0 ;
31143 int res1 = 0 ;
31144 PyObject *swig_obj[1] ;
31145
31146 if (!args) SWIG_fail;
31147 swig_obj[0] = args;
31148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31149 if (!SWIG_IsOK(res1)) {
31150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31151 }
31152 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31153 {
31154 PyThreadState* __tstate = wxPyBeginAllowThreads();
31155 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 resultobj = SWIG_From_int(static_cast< int >(result));
31160 return resultobj;
31161 fail:
31162 return NULL;
31163 }
31164
31165
31166 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31167 PyObject *resultobj = 0;
31168 wxPyApp *arg1 = (wxPyApp *) 0 ;
31169 int arg2 ;
31170 void *argp1 = 0 ;
31171 int res1 = 0 ;
31172 int val2 ;
31173 int ecode2 = 0 ;
31174 PyObject * obj0 = 0 ;
31175 PyObject * obj1 = 0 ;
31176 char * kwnames[] = {
31177 (char *) "self",(char *) "mode", NULL
31178 };
31179
31180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31182 if (!SWIG_IsOK(res1)) {
31183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31184 }
31185 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31186 ecode2 = SWIG_AsVal_int(obj1, &val2);
31187 if (!SWIG_IsOK(ecode2)) {
31188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31189 }
31190 arg2 = static_cast< int >(val2);
31191 {
31192 PyThreadState* __tstate = wxPyBeginAllowThreads();
31193 (arg1)->SetAssertMode(arg2);
31194 wxPyEndAllowThreads(__tstate);
31195 if (PyErr_Occurred()) SWIG_fail;
31196 }
31197 resultobj = SWIG_Py_Void();
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31205 PyObject *resultobj = 0;
31206 wxPyApp *arg1 = (wxPyApp *) 0 ;
31207 int result;
31208 void *argp1 = 0 ;
31209 int res1 = 0 ;
31210 PyObject *swig_obj[1] ;
31211
31212 if (!args) SWIG_fail;
31213 swig_obj[0] = args;
31214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31215 if (!SWIG_IsOK(res1)) {
31216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31217 }
31218 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = (int)(arg1)->GetAssertMode();
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_From_int(static_cast< int >(result));
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31233 PyObject *resultobj = 0;
31234 bool result;
31235
31236 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 {
31244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31245 }
31246 return resultobj;
31247 fail:
31248 return NULL;
31249 }
31250
31251
31252 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31253 PyObject *resultobj = 0;
31254 long result;
31255
31256 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 result = (long)wxPyApp::GetMacAboutMenuItemId();
31260 wxPyEndAllowThreads(__tstate);
31261 if (PyErr_Occurred()) SWIG_fail;
31262 }
31263 resultobj = SWIG_From_long(static_cast< long >(result));
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31271 PyObject *resultobj = 0;
31272 long result;
31273
31274 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_From_long(static_cast< long >(result));
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31289 PyObject *resultobj = 0;
31290 long result;
31291
31292 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = (long)wxPyApp::GetMacExitMenuItemId();
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 resultobj = SWIG_From_long(static_cast< long >(result));
31300 return resultobj;
31301 fail:
31302 return NULL;
31303 }
31304
31305
31306 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31307 PyObject *resultobj = 0;
31308 wxString result;
31309
31310 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 result = wxPyApp::GetMacHelpMenuTitleName();
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 {
31318 #if wxUSE_UNICODE
31319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31320 #else
31321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31322 #endif
31323 }
31324 return resultobj;
31325 fail:
31326 return NULL;
31327 }
31328
31329
31330 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31331 PyObject *resultobj = 0;
31332 bool arg1 ;
31333 bool val1 ;
31334 int ecode1 = 0 ;
31335 PyObject * obj0 = 0 ;
31336 char * kwnames[] = {
31337 (char *) "val", NULL
31338 };
31339
31340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31341 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31342 if (!SWIG_IsOK(ecode1)) {
31343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31344 }
31345 arg1 = static_cast< bool >(val1);
31346 {
31347 PyThreadState* __tstate = wxPyBeginAllowThreads();
31348 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31349 wxPyEndAllowThreads(__tstate);
31350 if (PyErr_Occurred()) SWIG_fail;
31351 }
31352 resultobj = SWIG_Py_Void();
31353 return resultobj;
31354 fail:
31355 return NULL;
31356 }
31357
31358
31359 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31360 PyObject *resultobj = 0;
31361 long arg1 ;
31362 long val1 ;
31363 int ecode1 = 0 ;
31364 PyObject * obj0 = 0 ;
31365 char * kwnames[] = {
31366 (char *) "val", NULL
31367 };
31368
31369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31370 ecode1 = SWIG_AsVal_long(obj0, &val1);
31371 if (!SWIG_IsOK(ecode1)) {
31372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31373 }
31374 arg1 = static_cast< long >(val1);
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 wxPyApp::SetMacAboutMenuItemId(arg1);
31378 wxPyEndAllowThreads(__tstate);
31379 if (PyErr_Occurred()) SWIG_fail;
31380 }
31381 resultobj = SWIG_Py_Void();
31382 return resultobj;
31383 fail:
31384 return NULL;
31385 }
31386
31387
31388 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31389 PyObject *resultobj = 0;
31390 long arg1 ;
31391 long val1 ;
31392 int ecode1 = 0 ;
31393 PyObject * obj0 = 0 ;
31394 char * kwnames[] = {
31395 (char *) "val", NULL
31396 };
31397
31398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31399 ecode1 = SWIG_AsVal_long(obj0, &val1);
31400 if (!SWIG_IsOK(ecode1)) {
31401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31402 }
31403 arg1 = static_cast< long >(val1);
31404 {
31405 PyThreadState* __tstate = wxPyBeginAllowThreads();
31406 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31407 wxPyEndAllowThreads(__tstate);
31408 if (PyErr_Occurred()) SWIG_fail;
31409 }
31410 resultobj = SWIG_Py_Void();
31411 return resultobj;
31412 fail:
31413 return NULL;
31414 }
31415
31416
31417 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31418 PyObject *resultobj = 0;
31419 long arg1 ;
31420 long val1 ;
31421 int ecode1 = 0 ;
31422 PyObject * obj0 = 0 ;
31423 char * kwnames[] = {
31424 (char *) "val", NULL
31425 };
31426
31427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31428 ecode1 = SWIG_AsVal_long(obj0, &val1);
31429 if (!SWIG_IsOK(ecode1)) {
31430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31431 }
31432 arg1 = static_cast< long >(val1);
31433 {
31434 PyThreadState* __tstate = wxPyBeginAllowThreads();
31435 wxPyApp::SetMacExitMenuItemId(arg1);
31436 wxPyEndAllowThreads(__tstate);
31437 if (PyErr_Occurred()) SWIG_fail;
31438 }
31439 resultobj = SWIG_Py_Void();
31440 return resultobj;
31441 fail:
31442 return NULL;
31443 }
31444
31445
31446 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31447 PyObject *resultobj = 0;
31448 wxString *arg1 = 0 ;
31449 bool temp1 = false ;
31450 PyObject * obj0 = 0 ;
31451 char * kwnames[] = {
31452 (char *) "val", NULL
31453 };
31454
31455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31456 {
31457 arg1 = wxString_in_helper(obj0);
31458 if (arg1 == NULL) SWIG_fail;
31459 temp1 = true;
31460 }
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 resultobj = SWIG_Py_Void();
31468 {
31469 if (temp1)
31470 delete arg1;
31471 }
31472 return resultobj;
31473 fail:
31474 {
31475 if (temp1)
31476 delete arg1;
31477 }
31478 return NULL;
31479 }
31480
31481
31482 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31483 PyObject *resultobj = 0;
31484 wxPyApp *arg1 = (wxPyApp *) 0 ;
31485 void *argp1 = 0 ;
31486 int res1 = 0 ;
31487 PyObject *swig_obj[1] ;
31488
31489 if (!args) SWIG_fail;
31490 swig_obj[0] = args;
31491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31492 if (!SWIG_IsOK(res1)) {
31493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31494 }
31495 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 (arg1)->_BootstrapApp();
31499 wxPyEndAllowThreads(__tstate);
31500 if (PyErr_Occurred()) SWIG_fail;
31501 }
31502 resultobj = SWIG_Py_Void();
31503 return resultobj;
31504 fail:
31505 return NULL;
31506 }
31507
31508
31509 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31510 PyObject *resultobj = 0;
31511 int result;
31512
31513 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 result = (int)wxPyApp_GetComCtl32Version();
31517 wxPyEndAllowThreads(__tstate);
31518 if (PyErr_Occurred()) SWIG_fail;
31519 }
31520 resultobj = SWIG_From_int(static_cast< int >(result));
31521 return resultobj;
31522 fail:
31523 return NULL;
31524 }
31525
31526
31527 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31528 PyObject *resultobj = 0;
31529 bool result;
31530
31531 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31532 {
31533 PyThreadState* __tstate = wxPyBeginAllowThreads();
31534 result = (bool)wxPyApp_IsDisplayAvailable();
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 {
31539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31540 }
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31548 PyObject *obj;
31549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31550 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31551 return SWIG_Py_Void();
31552 }
31553
31554 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 return SWIG_Python_InitShadowInstance(args);
31556 }
31557
31558 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31559 PyObject *resultobj = 0;
31560
31561 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31562 {
31563 PyThreadState* __tstate = wxPyBeginAllowThreads();
31564 wxExit();
31565 wxPyEndAllowThreads(__tstate);
31566 if (PyErr_Occurred()) SWIG_fail;
31567 }
31568 resultobj = SWIG_Py_Void();
31569 return resultobj;
31570 fail:
31571 return NULL;
31572 }
31573
31574
31575 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31576 PyObject *resultobj = 0;
31577 bool result;
31578
31579 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31580 {
31581 PyThreadState* __tstate = wxPyBeginAllowThreads();
31582 result = (bool)wxYield();
31583 wxPyEndAllowThreads(__tstate);
31584 if (PyErr_Occurred()) SWIG_fail;
31585 }
31586 {
31587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31588 }
31589 return resultobj;
31590 fail:
31591 return NULL;
31592 }
31593
31594
31595 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31596 PyObject *resultobj = 0;
31597 bool result;
31598
31599 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31600 {
31601 PyThreadState* __tstate = wxPyBeginAllowThreads();
31602 result = (bool)wxYieldIfNeeded();
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 {
31607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31608 }
31609 return resultobj;
31610 fail:
31611 return NULL;
31612 }
31613
31614
31615 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31616 PyObject *resultobj = 0;
31617 wxWindow *arg1 = (wxWindow *) NULL ;
31618 bool arg2 = (bool) false ;
31619 bool result;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 bool val2 ;
31623 int ecode2 = 0 ;
31624 PyObject * obj0 = 0 ;
31625 PyObject * obj1 = 0 ;
31626 char * kwnames[] = {
31627 (char *) "win",(char *) "onlyIfNeeded", NULL
31628 };
31629
31630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31631 if (obj0) {
31632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31633 if (!SWIG_IsOK(res1)) {
31634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31635 }
31636 arg1 = reinterpret_cast< wxWindow * >(argp1);
31637 }
31638 if (obj1) {
31639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31640 if (!SWIG_IsOK(ecode2)) {
31641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31642 }
31643 arg2 = static_cast< bool >(val2);
31644 }
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 result = (bool)wxSafeYield(arg1,arg2);
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 {
31652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31653 }
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 PyObject *resultobj = 0;
31662
31663 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 wxWakeUpIdle();
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_Py_Void();
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31678 PyObject *resultobj = 0;
31679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31680 wxEvent *arg2 = 0 ;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 void *argp2 = 0 ;
31684 int res2 = 0 ;
31685 PyObject * obj0 = 0 ;
31686 PyObject * obj1 = 0 ;
31687 char * kwnames[] = {
31688 (char *) "dest",(char *) "event", NULL
31689 };
31690
31691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31693 if (!SWIG_IsOK(res1)) {
31694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31695 }
31696 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31698 if (!SWIG_IsOK(res2)) {
31699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31700 }
31701 if (!argp2) {
31702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31703 }
31704 arg2 = reinterpret_cast< wxEvent * >(argp2);
31705 {
31706 PyThreadState* __tstate = wxPyBeginAllowThreads();
31707 wxPostEvent(arg1,*arg2);
31708 wxPyEndAllowThreads(__tstate);
31709 if (PyErr_Occurred()) SWIG_fail;
31710 }
31711 resultobj = SWIG_Py_Void();
31712 return resultobj;
31713 fail:
31714 return NULL;
31715 }
31716
31717
31718 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31719 PyObject *resultobj = 0;
31720
31721 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 wxApp_CleanUp();
31725 wxPyEndAllowThreads(__tstate);
31726 if (PyErr_Occurred()) SWIG_fail;
31727 }
31728 resultobj = SWIG_Py_Void();
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31736 PyObject *resultobj = 0;
31737 wxPyApp *result = 0 ;
31738
31739 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31740 {
31741 PyThreadState* __tstate = wxPyBeginAllowThreads();
31742 result = (wxPyApp *)wxPyGetApp();
31743 wxPyEndAllowThreads(__tstate);
31744 if (PyErr_Occurred()) SWIG_fail;
31745 }
31746 {
31747 resultobj = wxPyMake_wxObject(result, 0);
31748 }
31749 return resultobj;
31750 fail:
31751 return NULL;
31752 }
31753
31754
31755 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31756 PyObject *resultobj = 0;
31757 char *arg1 = (char *) 0 ;
31758 int res1 ;
31759 char *buf1 = 0 ;
31760 int alloc1 = 0 ;
31761 PyObject * obj0 = 0 ;
31762 char * kwnames[] = {
31763 (char *) "encoding", NULL
31764 };
31765
31766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31767 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31768 if (!SWIG_IsOK(res1)) {
31769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31770 }
31771 arg1 = buf1;
31772 {
31773 PyThreadState* __tstate = wxPyBeginAllowThreads();
31774 wxSetDefaultPyEncoding((char const *)arg1);
31775 wxPyEndAllowThreads(__tstate);
31776 if (PyErr_Occurred()) SWIG_fail;
31777 }
31778 resultobj = SWIG_Py_Void();
31779 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31780 return resultobj;
31781 fail:
31782 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 PyObject *resultobj = 0;
31789 char *result = 0 ;
31790
31791 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (char *)wxGetDefaultPyEncoding();
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 resultobj = SWIG_FromCharPtr(result);
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31806 PyObject *resultobj = 0;
31807 wxEventLoop *result = 0 ;
31808
31809 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 result = (wxEventLoop *)new wxEventLoop();
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31824 PyObject *resultobj = 0;
31825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31826 void *argp1 = 0 ;
31827 int res1 = 0 ;
31828 PyObject *swig_obj[1] ;
31829
31830 if (!args) SWIG_fail;
31831 swig_obj[0] = args;
31832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31833 if (!SWIG_IsOK(res1)) {
31834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31835 }
31836 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31837 {
31838 PyThreadState* __tstate = wxPyBeginAllowThreads();
31839 delete arg1;
31840
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_Py_Void();
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31852 PyObject *resultobj = 0;
31853 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31854 int result;
31855 void *argp1 = 0 ;
31856 int res1 = 0 ;
31857 PyObject *swig_obj[1] ;
31858
31859 if (!args) SWIG_fail;
31860 swig_obj[0] = args;
31861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31862 if (!SWIG_IsOK(res1)) {
31863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31864 }
31865 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31866 {
31867 PyThreadState* __tstate = wxPyBeginAllowThreads();
31868 result = (int)(arg1)->Run();
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_From_int(static_cast< int >(result));
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31880 PyObject *resultobj = 0;
31881 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31882 int arg2 = (int) 0 ;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 int val2 ;
31886 int ecode2 = 0 ;
31887 PyObject * obj0 = 0 ;
31888 PyObject * obj1 = 0 ;
31889 char * kwnames[] = {
31890 (char *) "self",(char *) "rc", NULL
31891 };
31892
31893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31895 if (!SWIG_IsOK(res1)) {
31896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31897 }
31898 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31899 if (obj1) {
31900 ecode2 = SWIG_AsVal_int(obj1, &val2);
31901 if (!SWIG_IsOK(ecode2)) {
31902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31903 }
31904 arg2 = static_cast< int >(val2);
31905 }
31906 {
31907 PyThreadState* __tstate = wxPyBeginAllowThreads();
31908 (arg1)->Exit(arg2);
31909 wxPyEndAllowThreads(__tstate);
31910 if (PyErr_Occurred()) SWIG_fail;
31911 }
31912 resultobj = SWIG_Py_Void();
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31920 PyObject *resultobj = 0;
31921 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31922 bool result;
31923 void *argp1 = 0 ;
31924 int res1 = 0 ;
31925 PyObject *swig_obj[1] ;
31926
31927 if (!args) SWIG_fail;
31928 swig_obj[0] = args;
31929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31930 if (!SWIG_IsOK(res1)) {
31931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31932 }
31933 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = (bool)((wxEventLoop const *)arg1)->Pending();
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 {
31941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31942 }
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31950 PyObject *resultobj = 0;
31951 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31952 bool result;
31953 void *argp1 = 0 ;
31954 int res1 = 0 ;
31955 PyObject *swig_obj[1] ;
31956
31957 if (!args) SWIG_fail;
31958 swig_obj[0] = args;
31959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31960 if (!SWIG_IsOK(res1)) {
31961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31962 }
31963 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31964 {
31965 PyThreadState* __tstate = wxPyBeginAllowThreads();
31966 result = (bool)(arg1)->Dispatch();
31967 wxPyEndAllowThreads(__tstate);
31968 if (PyErr_Occurred()) SWIG_fail;
31969 }
31970 {
31971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31972 }
31973 return resultobj;
31974 fail:
31975 return NULL;
31976 }
31977
31978
31979 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 PyObject *resultobj = 0;
31981 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31982 bool result;
31983 void *argp1 = 0 ;
31984 int res1 = 0 ;
31985 PyObject *swig_obj[1] ;
31986
31987 if (!args) SWIG_fail;
31988 swig_obj[0] = args;
31989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31990 if (!SWIG_IsOK(res1)) {
31991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31992 }
31993 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31994 {
31995 PyThreadState* __tstate = wxPyBeginAllowThreads();
31996 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31997 wxPyEndAllowThreads(__tstate);
31998 if (PyErr_Occurred()) SWIG_fail;
31999 }
32000 {
32001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32002 }
32003 return resultobj;
32004 fail:
32005 return NULL;
32006 }
32007
32008
32009 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32010 PyObject *resultobj = 0;
32011 wxEventLoop *result = 0 ;
32012
32013 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32014 {
32015 PyThreadState* __tstate = wxPyBeginAllowThreads();
32016 result = (wxEventLoop *)wxEventLoop::GetActive();
32017 wxPyEndAllowThreads(__tstate);
32018 if (PyErr_Occurred()) SWIG_fail;
32019 }
32020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32021 return resultobj;
32022 fail:
32023 return NULL;
32024 }
32025
32026
32027 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32028 PyObject *resultobj = 0;
32029 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32030 void *argp1 = 0 ;
32031 int res1 = 0 ;
32032 PyObject * obj0 = 0 ;
32033 char * kwnames[] = {
32034 (char *) "loop", NULL
32035 };
32036
32037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32039 if (!SWIG_IsOK(res1)) {
32040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32041 }
32042 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32043 {
32044 PyThreadState* __tstate = wxPyBeginAllowThreads();
32045 wxEventLoop::SetActive(arg1);
32046 wxPyEndAllowThreads(__tstate);
32047 if (PyErr_Occurred()) SWIG_fail;
32048 }
32049 resultobj = SWIG_Py_Void();
32050 return resultobj;
32051 fail:
32052 return NULL;
32053 }
32054
32055
32056 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32057 PyObject *obj;
32058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32059 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32060 return SWIG_Py_Void();
32061 }
32062
32063 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32064 return SWIG_Python_InitShadowInstance(args);
32065 }
32066
32067 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32068 PyObject *resultobj = 0;
32069 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32070 wxEventLoopActivator *result = 0 ;
32071 void *argp1 = 0 ;
32072 int res1 = 0 ;
32073 PyObject * obj0 = 0 ;
32074 char * kwnames[] = {
32075 (char *) "evtLoop", NULL
32076 };
32077
32078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32080 if (!SWIG_IsOK(res1)) {
32081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32082 }
32083 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32091 return resultobj;
32092 fail:
32093 return NULL;
32094 }
32095
32096
32097 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32098 PyObject *resultobj = 0;
32099 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32100 void *argp1 = 0 ;
32101 int res1 = 0 ;
32102 PyObject *swig_obj[1] ;
32103
32104 if (!args) SWIG_fail;
32105 swig_obj[0] = args;
32106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32107 if (!SWIG_IsOK(res1)) {
32108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32109 }
32110 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32111 {
32112 PyThreadState* __tstate = wxPyBeginAllowThreads();
32113 delete arg1;
32114
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 resultobj = SWIG_Py_Void();
32119 return resultobj;
32120 fail:
32121 return NULL;
32122 }
32123
32124
32125 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32126 PyObject *obj;
32127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32128 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32129 return SWIG_Py_Void();
32130 }
32131
32132 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 return SWIG_Python_InitShadowInstance(args);
32134 }
32135
32136 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32137 PyObject *resultobj = 0;
32138 int arg1 = (int) 0 ;
32139 int arg2 = (int) 0 ;
32140 int arg3 = (int) 0 ;
32141 wxAcceleratorEntry *result = 0 ;
32142 int val1 ;
32143 int ecode1 = 0 ;
32144 int val2 ;
32145 int ecode2 = 0 ;
32146 int val3 ;
32147 int ecode3 = 0 ;
32148 PyObject * obj0 = 0 ;
32149 PyObject * obj1 = 0 ;
32150 PyObject * obj2 = 0 ;
32151 char * kwnames[] = {
32152 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32153 };
32154
32155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32156 if (obj0) {
32157 ecode1 = SWIG_AsVal_int(obj0, &val1);
32158 if (!SWIG_IsOK(ecode1)) {
32159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32160 }
32161 arg1 = static_cast< int >(val1);
32162 }
32163 if (obj1) {
32164 ecode2 = SWIG_AsVal_int(obj1, &val2);
32165 if (!SWIG_IsOK(ecode2)) {
32166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32167 }
32168 arg2 = static_cast< int >(val2);
32169 }
32170 if (obj2) {
32171 ecode3 = SWIG_AsVal_int(obj2, &val3);
32172 if (!SWIG_IsOK(ecode3)) {
32173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32174 }
32175 arg3 = static_cast< int >(val3);
32176 }
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32180 wxPyEndAllowThreads(__tstate);
32181 if (PyErr_Occurred()) SWIG_fail;
32182 }
32183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32184 return resultobj;
32185 fail:
32186 return NULL;
32187 }
32188
32189
32190 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32191 PyObject *resultobj = 0;
32192 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32193 void *argp1 = 0 ;
32194 int res1 = 0 ;
32195 PyObject *swig_obj[1] ;
32196
32197 if (!args) SWIG_fail;
32198 swig_obj[0] = args;
32199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32200 if (!SWIG_IsOK(res1)) {
32201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32202 }
32203 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32204 {
32205 PyThreadState* __tstate = wxPyBeginAllowThreads();
32206 delete arg1;
32207
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 resultobj = SWIG_Py_Void();
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj = 0;
32220 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32221 int arg2 ;
32222 int arg3 ;
32223 int arg4 ;
32224 void *argp1 = 0 ;
32225 int res1 = 0 ;
32226 int val2 ;
32227 int ecode2 = 0 ;
32228 int val3 ;
32229 int ecode3 = 0 ;
32230 int val4 ;
32231 int ecode4 = 0 ;
32232 PyObject * obj0 = 0 ;
32233 PyObject * obj1 = 0 ;
32234 PyObject * obj2 = 0 ;
32235 PyObject * obj3 = 0 ;
32236 char * kwnames[] = {
32237 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32238 };
32239
32240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32244 }
32245 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32246 ecode2 = SWIG_AsVal_int(obj1, &val2);
32247 if (!SWIG_IsOK(ecode2)) {
32248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32249 }
32250 arg2 = static_cast< int >(val2);
32251 ecode3 = SWIG_AsVal_int(obj2, &val3);
32252 if (!SWIG_IsOK(ecode3)) {
32253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32254 }
32255 arg3 = static_cast< int >(val3);
32256 ecode4 = SWIG_AsVal_int(obj3, &val4);
32257 if (!SWIG_IsOK(ecode4)) {
32258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32259 }
32260 arg4 = static_cast< int >(val4);
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 (arg1)->Set(arg2,arg3,arg4);
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 resultobj = SWIG_Py_Void();
32268 return resultobj;
32269 fail:
32270 return NULL;
32271 }
32272
32273
32274 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32275 PyObject *resultobj = 0;
32276 wxString *arg1 = 0 ;
32277 wxAcceleratorEntry *result = 0 ;
32278 bool temp1 = false ;
32279 PyObject * obj0 = 0 ;
32280 char * kwnames[] = {
32281 (char *) "str", NULL
32282 };
32283
32284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32285 {
32286 arg1 = wxString_in_helper(obj0);
32287 if (arg1 == NULL) SWIG_fail;
32288 temp1 = true;
32289 }
32290 {
32291 PyThreadState* __tstate = wxPyBeginAllowThreads();
32292 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32293 wxPyEndAllowThreads(__tstate);
32294 if (PyErr_Occurred()) SWIG_fail;
32295 }
32296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32297 {
32298 if (temp1)
32299 delete arg1;
32300 }
32301 return resultobj;
32302 fail:
32303 {
32304 if (temp1)
32305 delete arg1;
32306 }
32307 return NULL;
32308 }
32309
32310
32311 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32312 PyObject *resultobj = 0;
32313 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32314 int result;
32315 void *argp1 = 0 ;
32316 int res1 = 0 ;
32317 PyObject *swig_obj[1] ;
32318
32319 if (!args) SWIG_fail;
32320 swig_obj[0] = args;
32321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32322 if (!SWIG_IsOK(res1)) {
32323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32324 }
32325 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 result = (int)(arg1)->GetFlags();
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 resultobj = SWIG_From_int(static_cast< int >(result));
32333 return resultobj;
32334 fail:
32335 return NULL;
32336 }
32337
32338
32339 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32340 PyObject *resultobj = 0;
32341 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32342 int result;
32343 void *argp1 = 0 ;
32344 int res1 = 0 ;
32345 PyObject *swig_obj[1] ;
32346
32347 if (!args) SWIG_fail;
32348 swig_obj[0] = args;
32349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32350 if (!SWIG_IsOK(res1)) {
32351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32352 }
32353 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32354 {
32355 PyThreadState* __tstate = wxPyBeginAllowThreads();
32356 result = (int)(arg1)->GetKeyCode();
32357 wxPyEndAllowThreads(__tstate);
32358 if (PyErr_Occurred()) SWIG_fail;
32359 }
32360 resultobj = SWIG_From_int(static_cast< int >(result));
32361 return resultobj;
32362 fail:
32363 return NULL;
32364 }
32365
32366
32367 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32368 PyObject *resultobj = 0;
32369 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32370 int result;
32371 void *argp1 = 0 ;
32372 int res1 = 0 ;
32373 PyObject *swig_obj[1] ;
32374
32375 if (!args) SWIG_fail;
32376 swig_obj[0] = args;
32377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32378 if (!SWIG_IsOK(res1)) {
32379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32380 }
32381 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 result = (int)(arg1)->GetCommand();
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 resultobj = SWIG_From_int(static_cast< int >(result));
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32398 bool result;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject *swig_obj[1] ;
32402
32403 if (!args) SWIG_fail;
32404 swig_obj[0] = args;
32405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32408 }
32409 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 {
32417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32428 wxString result;
32429 void *argp1 = 0 ;
32430 int res1 = 0 ;
32431 PyObject *swig_obj[1] ;
32432
32433 if (!args) SWIG_fail;
32434 swig_obj[0] = args;
32435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32438 }
32439 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32440 {
32441 PyThreadState* __tstate = wxPyBeginAllowThreads();
32442 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32443 wxPyEndAllowThreads(__tstate);
32444 if (PyErr_Occurred()) SWIG_fail;
32445 }
32446 {
32447 #if wxUSE_UNICODE
32448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32449 #else
32450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32451 #endif
32452 }
32453 return resultobj;
32454 fail:
32455 return NULL;
32456 }
32457
32458
32459 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32460 PyObject *resultobj = 0;
32461 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32462 wxString *arg2 = 0 ;
32463 bool result;
32464 void *argp1 = 0 ;
32465 int res1 = 0 ;
32466 bool temp2 = false ;
32467 PyObject * obj0 = 0 ;
32468 PyObject * obj1 = 0 ;
32469 char * kwnames[] = {
32470 (char *) "self",(char *) "str", NULL
32471 };
32472
32473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32475 if (!SWIG_IsOK(res1)) {
32476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32477 }
32478 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32479 {
32480 arg2 = wxString_in_helper(obj1);
32481 if (arg2 == NULL) SWIG_fail;
32482 temp2 = true;
32483 }
32484 {
32485 PyThreadState* __tstate = wxPyBeginAllowThreads();
32486 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32487 wxPyEndAllowThreads(__tstate);
32488 if (PyErr_Occurred()) SWIG_fail;
32489 }
32490 {
32491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32492 }
32493 {
32494 if (temp2)
32495 delete arg2;
32496 }
32497 return resultobj;
32498 fail:
32499 {
32500 if (temp2)
32501 delete arg2;
32502 }
32503 return NULL;
32504 }
32505
32506
32507 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32508 PyObject *obj;
32509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32510 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32511 return SWIG_Py_Void();
32512 }
32513
32514 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32515 return SWIG_Python_InitShadowInstance(args);
32516 }
32517
32518 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32519 PyObject *resultobj = 0;
32520 int arg1 ;
32521 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32522 wxAcceleratorTable *result = 0 ;
32523 PyObject * obj0 = 0 ;
32524 char * kwnames[] = {
32525 (char *) "n", NULL
32526 };
32527
32528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32529 {
32530 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32531 if (arg2) arg1 = PyList_Size(obj0);
32532 else arg1 = 0;
32533 }
32534 {
32535 PyThreadState* __tstate = wxPyBeginAllowThreads();
32536 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32537 wxPyEndAllowThreads(__tstate);
32538 if (PyErr_Occurred()) SWIG_fail;
32539 }
32540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32541 return resultobj;
32542 fail:
32543 return NULL;
32544 }
32545
32546
32547 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32548 PyObject *resultobj = 0;
32549 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32550 void *argp1 = 0 ;
32551 int res1 = 0 ;
32552 PyObject *swig_obj[1] ;
32553
32554 if (!args) SWIG_fail;
32555 swig_obj[0] = args;
32556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32557 if (!SWIG_IsOK(res1)) {
32558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32559 }
32560 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 delete arg1;
32564
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 resultobj = SWIG_Py_Void();
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32576 PyObject *resultobj = 0;
32577 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32578 bool result;
32579 void *argp1 = 0 ;
32580 int res1 = 0 ;
32581 PyObject *swig_obj[1] ;
32582
32583 if (!args) SWIG_fail;
32584 swig_obj[0] = args;
32585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32586 if (!SWIG_IsOK(res1)) {
32587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32588 }
32589 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 {
32597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32598 }
32599 return resultobj;
32600 fail:
32601 return NULL;
32602 }
32603
32604
32605 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32606 PyObject *obj;
32607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32608 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32609 return SWIG_Py_Void();
32610 }
32611
32612 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32613 return SWIG_Python_InitShadowInstance(args);
32614 }
32615
32616 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32617 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32618 return 1;
32619 }
32620
32621
32622 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32623 PyObject *pyobj = 0;
32624
32625 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32626 return pyobj;
32627 }
32628
32629
32630 SWIGINTERN int PanelNameStr_set(PyObject *) {
32631 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32632 return 1;
32633 }
32634
32635
32636 SWIGINTERN PyObject *PanelNameStr_get(void) {
32637 PyObject *pyobj = 0;
32638
32639 {
32640 #if wxUSE_UNICODE
32641 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32642 #else
32643 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32644 #endif
32645 }
32646 return pyobj;
32647 }
32648
32649
32650 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32651 PyObject *resultobj = 0;
32652 wxVisualAttributes *result = 0 ;
32653
32654 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32655 {
32656 PyThreadState* __tstate = wxPyBeginAllowThreads();
32657 result = (wxVisualAttributes *)new_wxVisualAttributes();
32658 wxPyEndAllowThreads(__tstate);
32659 if (PyErr_Occurred()) SWIG_fail;
32660 }
32661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32662 return resultobj;
32663 fail:
32664 return NULL;
32665 }
32666
32667
32668 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32669 PyObject *resultobj = 0;
32670 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32671 void *argp1 = 0 ;
32672 int res1 = 0 ;
32673 PyObject *swig_obj[1] ;
32674
32675 if (!args) SWIG_fail;
32676 swig_obj[0] = args;
32677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32678 if (!SWIG_IsOK(res1)) {
32679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32680 }
32681 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32682 {
32683 PyThreadState* __tstate = wxPyBeginAllowThreads();
32684 delete_wxVisualAttributes(arg1);
32685
32686 wxPyEndAllowThreads(__tstate);
32687 if (PyErr_Occurred()) SWIG_fail;
32688 }
32689 resultobj = SWIG_Py_Void();
32690 return resultobj;
32691 fail:
32692 return NULL;
32693 }
32694
32695
32696 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32697 PyObject *resultobj = 0;
32698 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32699 wxFont *arg2 = (wxFont *) 0 ;
32700 void *argp1 = 0 ;
32701 int res1 = 0 ;
32702 void *argp2 = 0 ;
32703 int res2 = 0 ;
32704 PyObject *swig_obj[2] ;
32705
32706 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32708 if (!SWIG_IsOK(res1)) {
32709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32710 }
32711 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32712 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32713 if (!SWIG_IsOK(res2)) {
32714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32715 }
32716 arg2 = reinterpret_cast< wxFont * >(argp2);
32717 if (arg1) (arg1)->font = *arg2;
32718
32719 resultobj = SWIG_Py_Void();
32720 return resultobj;
32721 fail:
32722 return NULL;
32723 }
32724
32725
32726 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32727 PyObject *resultobj = 0;
32728 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32729 wxFont *result = 0 ;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 PyObject *swig_obj[1] ;
32733
32734 if (!args) SWIG_fail;
32735 swig_obj[0] = args;
32736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32737 if (!SWIG_IsOK(res1)) {
32738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32739 }
32740 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32741 result = (wxFont *)& ((arg1)->font);
32742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32743 return resultobj;
32744 fail:
32745 return NULL;
32746 }
32747
32748
32749 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32750 PyObject *resultobj = 0;
32751 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32752 wxColour *arg2 = (wxColour *) 0 ;
32753 void *argp1 = 0 ;
32754 int res1 = 0 ;
32755 void *argp2 = 0 ;
32756 int res2 = 0 ;
32757 PyObject *swig_obj[2] ;
32758
32759 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32761 if (!SWIG_IsOK(res1)) {
32762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32763 }
32764 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32765 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32766 if (!SWIG_IsOK(res2)) {
32767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32768 }
32769 arg2 = reinterpret_cast< wxColour * >(argp2);
32770 if (arg1) (arg1)->colFg = *arg2;
32771
32772 resultobj = SWIG_Py_Void();
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32782 wxColour *result = 0 ;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32792 }
32793 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32794 result = (wxColour *)& ((arg1)->colFg);
32795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32796 return resultobj;
32797 fail:
32798 return NULL;
32799 }
32800
32801
32802 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32803 PyObject *resultobj = 0;
32804 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32805 wxColour *arg2 = (wxColour *) 0 ;
32806 void *argp1 = 0 ;
32807 int res1 = 0 ;
32808 void *argp2 = 0 ;
32809 int res2 = 0 ;
32810 PyObject *swig_obj[2] ;
32811
32812 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32814 if (!SWIG_IsOK(res1)) {
32815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32816 }
32817 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32818 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32819 if (!SWIG_IsOK(res2)) {
32820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32821 }
32822 arg2 = reinterpret_cast< wxColour * >(argp2);
32823 if (arg1) (arg1)->colBg = *arg2;
32824
32825 resultobj = SWIG_Py_Void();
32826 return resultobj;
32827 fail:
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32833 PyObject *resultobj = 0;
32834 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32835 wxColour *result = 0 ;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 PyObject *swig_obj[1] ;
32839
32840 if (!args) SWIG_fail;
32841 swig_obj[0] = args;
32842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32843 if (!SWIG_IsOK(res1)) {
32844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32845 }
32846 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32847 result = (wxColour *)& ((arg1)->colBg);
32848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32856 PyObject *obj;
32857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32858 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32859 return SWIG_Py_Void();
32860 }
32861
32862 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32863 return SWIG_Python_InitShadowInstance(args);
32864 }
32865
32866 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32867 PyObject *resultobj = 0;
32868 wxWindow *arg1 = (wxWindow *) 0 ;
32869 int arg2 = (int) (int)-1 ;
32870 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32871 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32872 wxSize const &arg4_defvalue = wxDefaultSize ;
32873 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32874 long arg5 = (long) 0 ;
32875 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32876 wxString *arg6 = (wxString *) &arg6_defvalue ;
32877 wxWindow *result = 0 ;
32878 void *argp1 = 0 ;
32879 int res1 = 0 ;
32880 int val2 ;
32881 int ecode2 = 0 ;
32882 wxPoint temp3 ;
32883 wxSize temp4 ;
32884 long val5 ;
32885 int ecode5 = 0 ;
32886 bool temp6 = false ;
32887 PyObject * obj0 = 0 ;
32888 PyObject * obj1 = 0 ;
32889 PyObject * obj2 = 0 ;
32890 PyObject * obj3 = 0 ;
32891 PyObject * obj4 = 0 ;
32892 PyObject * obj5 = 0 ;
32893 char * kwnames[] = {
32894 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32895 };
32896
32897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32899 if (!SWIG_IsOK(res1)) {
32900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32901 }
32902 arg1 = reinterpret_cast< wxWindow * >(argp1);
32903 if (obj1) {
32904 ecode2 = SWIG_AsVal_int(obj1, &val2);
32905 if (!SWIG_IsOK(ecode2)) {
32906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32907 }
32908 arg2 = static_cast< int >(val2);
32909 }
32910 if (obj2) {
32911 {
32912 arg3 = &temp3;
32913 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32914 }
32915 }
32916 if (obj3) {
32917 {
32918 arg4 = &temp4;
32919 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32920 }
32921 }
32922 if (obj4) {
32923 ecode5 = SWIG_AsVal_long(obj4, &val5);
32924 if (!SWIG_IsOK(ecode5)) {
32925 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32926 }
32927 arg5 = static_cast< long >(val5);
32928 }
32929 if (obj5) {
32930 {
32931 arg6 = wxString_in_helper(obj5);
32932 if (arg6 == NULL) SWIG_fail;
32933 temp6 = true;
32934 }
32935 }
32936 {
32937 if (!wxPyCheckForApp()) SWIG_fail;
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32944 {
32945 if (temp6)
32946 delete arg6;
32947 }
32948 return resultobj;
32949 fail:
32950 {
32951 if (temp6)
32952 delete arg6;
32953 }
32954 return NULL;
32955 }
32956
32957
32958 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32959 PyObject *resultobj = 0;
32960 wxWindow *result = 0 ;
32961
32962 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32963 {
32964 if (!wxPyCheckForApp()) SWIG_fail;
32965 PyThreadState* __tstate = wxPyBeginAllowThreads();
32966 result = (wxWindow *)new wxWindow();
32967 wxPyEndAllowThreads(__tstate);
32968 if (PyErr_Occurred()) SWIG_fail;
32969 }
32970 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32971 return resultobj;
32972 fail:
32973 return NULL;
32974 }
32975
32976
32977 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32978 PyObject *resultobj = 0;
32979 wxWindow *arg1 = (wxWindow *) 0 ;
32980 wxWindow *arg2 = (wxWindow *) 0 ;
32981 int arg3 = (int) (int)-1 ;
32982 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32983 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32984 wxSize const &arg5_defvalue = wxDefaultSize ;
32985 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32986 long arg6 = (long) 0 ;
32987 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32988 wxString *arg7 = (wxString *) &arg7_defvalue ;
32989 bool result;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 void *argp2 = 0 ;
32993 int res2 = 0 ;
32994 int val3 ;
32995 int ecode3 = 0 ;
32996 wxPoint temp4 ;
32997 wxSize temp5 ;
32998 long val6 ;
32999 int ecode6 = 0 ;
33000 bool temp7 = false ;
33001 PyObject * obj0 = 0 ;
33002 PyObject * obj1 = 0 ;
33003 PyObject * obj2 = 0 ;
33004 PyObject * obj3 = 0 ;
33005 PyObject * obj4 = 0 ;
33006 PyObject * obj5 = 0 ;
33007 PyObject * obj6 = 0 ;
33008 char * kwnames[] = {
33009 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33010 };
33011
33012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33014 if (!SWIG_IsOK(res1)) {
33015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33016 }
33017 arg1 = reinterpret_cast< wxWindow * >(argp1);
33018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33019 if (!SWIG_IsOK(res2)) {
33020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33021 }
33022 arg2 = reinterpret_cast< wxWindow * >(argp2);
33023 if (obj2) {
33024 ecode3 = SWIG_AsVal_int(obj2, &val3);
33025 if (!SWIG_IsOK(ecode3)) {
33026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33027 }
33028 arg3 = static_cast< int >(val3);
33029 }
33030 if (obj3) {
33031 {
33032 arg4 = &temp4;
33033 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33034 }
33035 }
33036 if (obj4) {
33037 {
33038 arg5 = &temp5;
33039 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33040 }
33041 }
33042 if (obj5) {
33043 ecode6 = SWIG_AsVal_long(obj5, &val6);
33044 if (!SWIG_IsOK(ecode6)) {
33045 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33046 }
33047 arg6 = static_cast< long >(val6);
33048 }
33049 if (obj6) {
33050 {
33051 arg7 = wxString_in_helper(obj6);
33052 if (arg7 == NULL) SWIG_fail;
33053 temp7 = true;
33054 }
33055 }
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 {
33063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33064 }
33065 {
33066 if (temp7)
33067 delete arg7;
33068 }
33069 return resultobj;
33070 fail:
33071 {
33072 if (temp7)
33073 delete arg7;
33074 }
33075 return NULL;
33076 }
33077
33078
33079 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33080 PyObject *resultobj = 0;
33081 wxWindow *arg1 = (wxWindow *) 0 ;
33082 bool arg2 = (bool) false ;
33083 bool result;
33084 void *argp1 = 0 ;
33085 int res1 = 0 ;
33086 bool val2 ;
33087 int ecode2 = 0 ;
33088 PyObject * obj0 = 0 ;
33089 PyObject * obj1 = 0 ;
33090 char * kwnames[] = {
33091 (char *) "self",(char *) "force", NULL
33092 };
33093
33094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33096 if (!SWIG_IsOK(res1)) {
33097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33098 }
33099 arg1 = reinterpret_cast< wxWindow * >(argp1);
33100 if (obj1) {
33101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33102 if (!SWIG_IsOK(ecode2)) {
33103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33104 }
33105 arg2 = static_cast< bool >(val2);
33106 }
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (bool)(arg1)->Close(arg2);
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33123 PyObject *resultobj = 0;
33124 wxWindow *arg1 = (wxWindow *) 0 ;
33125 bool result;
33126 void *argp1 = 0 ;
33127 int res1 = 0 ;
33128 PyObject *swig_obj[1] ;
33129
33130 if (!args) SWIG_fail;
33131 swig_obj[0] = args;
33132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33133 if (!SWIG_IsOK(res1)) {
33134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (bool)(arg1)->Destroy();
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 {
33144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33145 }
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 bool result;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 PyObject *swig_obj[1] ;
33159
33160 if (!args) SWIG_fail;
33161 swig_obj[0] = args;
33162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 {
33168 PyThreadState* __tstate = wxPyBeginAllowThreads();
33169 result = (bool)(arg1)->DestroyChildren();
33170 wxPyEndAllowThreads(__tstate);
33171 if (PyErr_Occurred()) SWIG_fail;
33172 }
33173 {
33174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33175 }
33176 return resultobj;
33177 fail:
33178 return NULL;
33179 }
33180
33181
33182 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33183 PyObject *resultobj = 0;
33184 wxWindow *arg1 = (wxWindow *) 0 ;
33185 bool result;
33186 void *argp1 = 0 ;
33187 int res1 = 0 ;
33188 PyObject *swig_obj[1] ;
33189
33190 if (!args) SWIG_fail;
33191 swig_obj[0] = args;
33192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33193 if (!SWIG_IsOK(res1)) {
33194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33195 }
33196 arg1 = reinterpret_cast< wxWindow * >(argp1);
33197 {
33198 PyThreadState* __tstate = wxPyBeginAllowThreads();
33199 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33200 wxPyEndAllowThreads(__tstate);
33201 if (PyErr_Occurred()) SWIG_fail;
33202 }
33203 {
33204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33205 }
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj = 0;
33214 wxWindow *arg1 = (wxWindow *) 0 ;
33215 wxString *arg2 = 0 ;
33216 void *argp1 = 0 ;
33217 int res1 = 0 ;
33218 bool temp2 = false ;
33219 PyObject * obj0 = 0 ;
33220 PyObject * obj1 = 0 ;
33221 char * kwnames[] = {
33222 (char *) "self",(char *) "label", NULL
33223 };
33224
33225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33227 if (!SWIG_IsOK(res1)) {
33228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33229 }
33230 arg1 = reinterpret_cast< wxWindow * >(argp1);
33231 {
33232 arg2 = wxString_in_helper(obj1);
33233 if (arg2 == NULL) SWIG_fail;
33234 temp2 = true;
33235 }
33236 {
33237 PyThreadState* __tstate = wxPyBeginAllowThreads();
33238 (arg1)->SetLabel((wxString const &)*arg2);
33239 wxPyEndAllowThreads(__tstate);
33240 if (PyErr_Occurred()) SWIG_fail;
33241 }
33242 resultobj = SWIG_Py_Void();
33243 {
33244 if (temp2)
33245 delete arg2;
33246 }
33247 return resultobj;
33248 fail:
33249 {
33250 if (temp2)
33251 delete arg2;
33252 }
33253 return NULL;
33254 }
33255
33256
33257 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33258 PyObject *resultobj = 0;
33259 wxWindow *arg1 = (wxWindow *) 0 ;
33260 wxString result;
33261 void *argp1 = 0 ;
33262 int res1 = 0 ;
33263 PyObject *swig_obj[1] ;
33264
33265 if (!args) SWIG_fail;
33266 swig_obj[0] = args;
33267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33268 if (!SWIG_IsOK(res1)) {
33269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33270 }
33271 arg1 = reinterpret_cast< wxWindow * >(argp1);
33272 {
33273 PyThreadState* __tstate = wxPyBeginAllowThreads();
33274 result = ((wxWindow const *)arg1)->GetLabel();
33275 wxPyEndAllowThreads(__tstate);
33276 if (PyErr_Occurred()) SWIG_fail;
33277 }
33278 {
33279 #if wxUSE_UNICODE
33280 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33281 #else
33282 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33283 #endif
33284 }
33285 return resultobj;
33286 fail:
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33292 PyObject *resultobj = 0;
33293 wxWindow *arg1 = (wxWindow *) 0 ;
33294 wxString *arg2 = 0 ;
33295 void *argp1 = 0 ;
33296 int res1 = 0 ;
33297 bool temp2 = false ;
33298 PyObject * obj0 = 0 ;
33299 PyObject * obj1 = 0 ;
33300 char * kwnames[] = {
33301 (char *) "self",(char *) "name", NULL
33302 };
33303
33304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33306 if (!SWIG_IsOK(res1)) {
33307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33308 }
33309 arg1 = reinterpret_cast< wxWindow * >(argp1);
33310 {
33311 arg2 = wxString_in_helper(obj1);
33312 if (arg2 == NULL) SWIG_fail;
33313 temp2 = true;
33314 }
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 (arg1)->SetName((wxString const &)*arg2);
33318 wxPyEndAllowThreads(__tstate);
33319 if (PyErr_Occurred()) SWIG_fail;
33320 }
33321 resultobj = SWIG_Py_Void();
33322 {
33323 if (temp2)
33324 delete arg2;
33325 }
33326 return resultobj;
33327 fail:
33328 {
33329 if (temp2)
33330 delete arg2;
33331 }
33332 return NULL;
33333 }
33334
33335
33336 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33337 PyObject *resultobj = 0;
33338 wxWindow *arg1 = (wxWindow *) 0 ;
33339 wxString result;
33340 void *argp1 = 0 ;
33341 int res1 = 0 ;
33342 PyObject *swig_obj[1] ;
33343
33344 if (!args) SWIG_fail;
33345 swig_obj[0] = args;
33346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33347 if (!SWIG_IsOK(res1)) {
33348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33349 }
33350 arg1 = reinterpret_cast< wxWindow * >(argp1);
33351 {
33352 PyThreadState* __tstate = wxPyBeginAllowThreads();
33353 result = ((wxWindow const *)arg1)->GetName();
33354 wxPyEndAllowThreads(__tstate);
33355 if (PyErr_Occurred()) SWIG_fail;
33356 }
33357 {
33358 #if wxUSE_UNICODE
33359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33360 #else
33361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33362 #endif
33363 }
33364 return resultobj;
33365 fail:
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33371 PyObject *resultobj = 0;
33372 wxWindow *arg1 = (wxWindow *) 0 ;
33373 wxWindowVariant arg2 ;
33374 void *argp1 = 0 ;
33375 int res1 = 0 ;
33376 int val2 ;
33377 int ecode2 = 0 ;
33378 PyObject * obj0 = 0 ;
33379 PyObject * obj1 = 0 ;
33380 char * kwnames[] = {
33381 (char *) "self",(char *) "variant", NULL
33382 };
33383
33384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33386 if (!SWIG_IsOK(res1)) {
33387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33388 }
33389 arg1 = reinterpret_cast< wxWindow * >(argp1);
33390 ecode2 = SWIG_AsVal_int(obj1, &val2);
33391 if (!SWIG_IsOK(ecode2)) {
33392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33393 }
33394 arg2 = static_cast< wxWindowVariant >(val2);
33395 {
33396 PyThreadState* __tstate = wxPyBeginAllowThreads();
33397 (arg1)->SetWindowVariant(arg2);
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 resultobj = SWIG_Py_Void();
33402 return resultobj;
33403 fail:
33404 return NULL;
33405 }
33406
33407
33408 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33409 PyObject *resultobj = 0;
33410 wxWindow *arg1 = (wxWindow *) 0 ;
33411 wxWindowVariant result;
33412 void *argp1 = 0 ;
33413 int res1 = 0 ;
33414 PyObject *swig_obj[1] ;
33415
33416 if (!args) SWIG_fail;
33417 swig_obj[0] = args;
33418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33419 if (!SWIG_IsOK(res1)) {
33420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33421 }
33422 arg1 = reinterpret_cast< wxWindow * >(argp1);
33423 {
33424 PyThreadState* __tstate = wxPyBeginAllowThreads();
33425 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33426 wxPyEndAllowThreads(__tstate);
33427 if (PyErr_Occurred()) SWIG_fail;
33428 }
33429 resultobj = SWIG_From_int(static_cast< int >(result));
33430 return resultobj;
33431 fail:
33432 return NULL;
33433 }
33434
33435
33436 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33437 PyObject *resultobj = 0;
33438 wxWindow *arg1 = (wxWindow *) 0 ;
33439 int arg2 ;
33440 void *argp1 = 0 ;
33441 int res1 = 0 ;
33442 int val2 ;
33443 int ecode2 = 0 ;
33444 PyObject * obj0 = 0 ;
33445 PyObject * obj1 = 0 ;
33446 char * kwnames[] = {
33447 (char *) "self",(char *) "winid", NULL
33448 };
33449
33450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33452 if (!SWIG_IsOK(res1)) {
33453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33454 }
33455 arg1 = reinterpret_cast< wxWindow * >(argp1);
33456 ecode2 = SWIG_AsVal_int(obj1, &val2);
33457 if (!SWIG_IsOK(ecode2)) {
33458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33459 }
33460 arg2 = static_cast< int >(val2);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 (arg1)->SetId(arg2);
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 resultobj = SWIG_Py_Void();
33468 return resultobj;
33469 fail:
33470 return NULL;
33471 }
33472
33473
33474 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33475 PyObject *resultobj = 0;
33476 wxWindow *arg1 = (wxWindow *) 0 ;
33477 int result;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 PyObject *swig_obj[1] ;
33481
33482 if (!args) SWIG_fail;
33483 swig_obj[0] = args;
33484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33485 if (!SWIG_IsOK(res1)) {
33486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33487 }
33488 arg1 = reinterpret_cast< wxWindow * >(argp1);
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 result = (int)((wxWindow const *)arg1)->GetId();
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = SWIG_From_int(static_cast< int >(result));
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33503 PyObject *resultobj = 0;
33504 int result;
33505
33506 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33507 {
33508 PyThreadState* __tstate = wxPyBeginAllowThreads();
33509 result = (int)wxWindow::NewControlId();
33510 wxPyEndAllowThreads(__tstate);
33511 if (PyErr_Occurred()) SWIG_fail;
33512 }
33513 resultobj = SWIG_From_int(static_cast< int >(result));
33514 return resultobj;
33515 fail:
33516 return NULL;
33517 }
33518
33519
33520 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj = 0;
33522 int arg1 ;
33523 int result;
33524 int val1 ;
33525 int ecode1 = 0 ;
33526 PyObject * obj0 = 0 ;
33527 char * kwnames[] = {
33528 (char *) "winid", NULL
33529 };
33530
33531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33532 ecode1 = SWIG_AsVal_int(obj0, &val1);
33533 if (!SWIG_IsOK(ecode1)) {
33534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33535 }
33536 arg1 = static_cast< int >(val1);
33537 {
33538 PyThreadState* __tstate = wxPyBeginAllowThreads();
33539 result = (int)wxWindow::NextControlId(arg1);
33540 wxPyEndAllowThreads(__tstate);
33541 if (PyErr_Occurred()) SWIG_fail;
33542 }
33543 resultobj = SWIG_From_int(static_cast< int >(result));
33544 return resultobj;
33545 fail:
33546 return NULL;
33547 }
33548
33549
33550 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33551 PyObject *resultobj = 0;
33552 int arg1 ;
33553 int result;
33554 int val1 ;
33555 int ecode1 = 0 ;
33556 PyObject * obj0 = 0 ;
33557 char * kwnames[] = {
33558 (char *) "winid", NULL
33559 };
33560
33561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33562 ecode1 = SWIG_AsVal_int(obj0, &val1);
33563 if (!SWIG_IsOK(ecode1)) {
33564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33565 }
33566 arg1 = static_cast< int >(val1);
33567 {
33568 PyThreadState* __tstate = wxPyBeginAllowThreads();
33569 result = (int)wxWindow::PrevControlId(arg1);
33570 wxPyEndAllowThreads(__tstate);
33571 if (PyErr_Occurred()) SWIG_fail;
33572 }
33573 resultobj = SWIG_From_int(static_cast< int >(result));
33574 return resultobj;
33575 fail:
33576 return NULL;
33577 }
33578
33579
33580 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33581 PyObject *resultobj = 0;
33582 wxWindow *arg1 = (wxWindow *) 0 ;
33583 wxLayoutDirection result;
33584 void *argp1 = 0 ;
33585 int res1 = 0 ;
33586 PyObject *swig_obj[1] ;
33587
33588 if (!args) SWIG_fail;
33589 swig_obj[0] = args;
33590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33591 if (!SWIG_IsOK(res1)) {
33592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33593 }
33594 arg1 = reinterpret_cast< wxWindow * >(argp1);
33595 {
33596 PyThreadState* __tstate = wxPyBeginAllowThreads();
33597 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33598 wxPyEndAllowThreads(__tstate);
33599 if (PyErr_Occurred()) SWIG_fail;
33600 }
33601 resultobj = SWIG_From_int(static_cast< int >(result));
33602 return resultobj;
33603 fail:
33604 return NULL;
33605 }
33606
33607
33608 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33609 PyObject *resultobj = 0;
33610 wxWindow *arg1 = (wxWindow *) 0 ;
33611 wxLayoutDirection arg2 ;
33612 void *argp1 = 0 ;
33613 int res1 = 0 ;
33614 int val2 ;
33615 int ecode2 = 0 ;
33616 PyObject * obj0 = 0 ;
33617 PyObject * obj1 = 0 ;
33618 char * kwnames[] = {
33619 (char *) "self",(char *) "dir", NULL
33620 };
33621
33622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33624 if (!SWIG_IsOK(res1)) {
33625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33626 }
33627 arg1 = reinterpret_cast< wxWindow * >(argp1);
33628 ecode2 = SWIG_AsVal_int(obj1, &val2);
33629 if (!SWIG_IsOK(ecode2)) {
33630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33631 }
33632 arg2 = static_cast< wxLayoutDirection >(val2);
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 (arg1)->SetLayoutDirection(arg2);
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 resultobj = SWIG_Py_Void();
33640 return resultobj;
33641 fail:
33642 return NULL;
33643 }
33644
33645
33646 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33647 PyObject *resultobj = 0;
33648 wxWindow *arg1 = (wxWindow *) 0 ;
33649 int arg2 ;
33650 int arg3 ;
33651 int arg4 ;
33652 int result;
33653 void *argp1 = 0 ;
33654 int res1 = 0 ;
33655 int val2 ;
33656 int ecode2 = 0 ;
33657 int val3 ;
33658 int ecode3 = 0 ;
33659 int val4 ;
33660 int ecode4 = 0 ;
33661 PyObject * obj0 = 0 ;
33662 PyObject * obj1 = 0 ;
33663 PyObject * obj2 = 0 ;
33664 PyObject * obj3 = 0 ;
33665 char * kwnames[] = {
33666 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33667 };
33668
33669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33671 if (!SWIG_IsOK(res1)) {
33672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33673 }
33674 arg1 = reinterpret_cast< wxWindow * >(argp1);
33675 ecode2 = SWIG_AsVal_int(obj1, &val2);
33676 if (!SWIG_IsOK(ecode2)) {
33677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33678 }
33679 arg2 = static_cast< int >(val2);
33680 ecode3 = SWIG_AsVal_int(obj2, &val3);
33681 if (!SWIG_IsOK(ecode3)) {
33682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33683 }
33684 arg3 = static_cast< int >(val3);
33685 ecode4 = SWIG_AsVal_int(obj3, &val4);
33686 if (!SWIG_IsOK(ecode4)) {
33687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33688 }
33689 arg4 = static_cast< int >(val4);
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33693 wxPyEndAllowThreads(__tstate);
33694 if (PyErr_Occurred()) SWIG_fail;
33695 }
33696 resultobj = SWIG_From_int(static_cast< int >(result));
33697 return resultobj;
33698 fail:
33699 return NULL;
33700 }
33701
33702
33703 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33704 PyObject *resultobj = 0;
33705 wxWindow *arg1 = (wxWindow *) 0 ;
33706 wxSize *arg2 = 0 ;
33707 void *argp1 = 0 ;
33708 int res1 = 0 ;
33709 wxSize temp2 ;
33710 PyObject * obj0 = 0 ;
33711 PyObject * obj1 = 0 ;
33712 char * kwnames[] = {
33713 (char *) "self",(char *) "size", NULL
33714 };
33715
33716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33718 if (!SWIG_IsOK(res1)) {
33719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33720 }
33721 arg1 = reinterpret_cast< wxWindow * >(argp1);
33722 {
33723 arg2 = &temp2;
33724 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33725 }
33726 {
33727 PyThreadState* __tstate = wxPyBeginAllowThreads();
33728 (arg1)->SetSize((wxSize const &)*arg2);
33729 wxPyEndAllowThreads(__tstate);
33730 if (PyErr_Occurred()) SWIG_fail;
33731 }
33732 resultobj = SWIG_Py_Void();
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj = 0;
33741 wxWindow *arg1 = (wxWindow *) 0 ;
33742 int arg2 ;
33743 int arg3 ;
33744 int arg4 ;
33745 int arg5 ;
33746 int arg6 = (int) wxSIZE_AUTO ;
33747 void *argp1 = 0 ;
33748 int res1 = 0 ;
33749 int val2 ;
33750 int ecode2 = 0 ;
33751 int val3 ;
33752 int ecode3 = 0 ;
33753 int val4 ;
33754 int ecode4 = 0 ;
33755 int val5 ;
33756 int ecode5 = 0 ;
33757 int val6 ;
33758 int ecode6 = 0 ;
33759 PyObject * obj0 = 0 ;
33760 PyObject * obj1 = 0 ;
33761 PyObject * obj2 = 0 ;
33762 PyObject * obj3 = 0 ;
33763 PyObject * obj4 = 0 ;
33764 PyObject * obj5 = 0 ;
33765 char * kwnames[] = {
33766 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33767 };
33768
33769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33773 }
33774 arg1 = reinterpret_cast< wxWindow * >(argp1);
33775 ecode2 = SWIG_AsVal_int(obj1, &val2);
33776 if (!SWIG_IsOK(ecode2)) {
33777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33778 }
33779 arg2 = static_cast< int >(val2);
33780 ecode3 = SWIG_AsVal_int(obj2, &val3);
33781 if (!SWIG_IsOK(ecode3)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33783 }
33784 arg3 = static_cast< int >(val3);
33785 ecode4 = SWIG_AsVal_int(obj3, &val4);
33786 if (!SWIG_IsOK(ecode4)) {
33787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33788 }
33789 arg4 = static_cast< int >(val4);
33790 ecode5 = SWIG_AsVal_int(obj4, &val5);
33791 if (!SWIG_IsOK(ecode5)) {
33792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33793 }
33794 arg5 = static_cast< int >(val5);
33795 if (obj5) {
33796 ecode6 = SWIG_AsVal_int(obj5, &val6);
33797 if (!SWIG_IsOK(ecode6)) {
33798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33799 }
33800 arg6 = static_cast< int >(val6);
33801 }
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 resultobj = SWIG_Py_Void();
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj = 0;
33817 wxWindow *arg1 = (wxWindow *) 0 ;
33818 wxRect *arg2 = 0 ;
33819 int arg3 = (int) wxSIZE_AUTO ;
33820 void *argp1 = 0 ;
33821 int res1 = 0 ;
33822 wxRect temp2 ;
33823 int val3 ;
33824 int ecode3 = 0 ;
33825 PyObject * obj0 = 0 ;
33826 PyObject * obj1 = 0 ;
33827 PyObject * obj2 = 0 ;
33828 char * kwnames[] = {
33829 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33830 };
33831
33832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 {
33839 arg2 = &temp2;
33840 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33841 }
33842 if (obj2) {
33843 ecode3 = SWIG_AsVal_int(obj2, &val3);
33844 if (!SWIG_IsOK(ecode3)) {
33845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33846 }
33847 arg3 = static_cast< int >(val3);
33848 }
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33852 wxPyEndAllowThreads(__tstate);
33853 if (PyErr_Occurred()) SWIG_fail;
33854 }
33855 resultobj = SWIG_Py_Void();
33856 return resultobj;
33857 fail:
33858 return NULL;
33859 }
33860
33861
33862 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33863 PyObject *resultobj = 0;
33864 wxWindow *arg1 = (wxWindow *) 0 ;
33865 int arg2 ;
33866 int arg3 ;
33867 void *argp1 = 0 ;
33868 int res1 = 0 ;
33869 int val2 ;
33870 int ecode2 = 0 ;
33871 int val3 ;
33872 int ecode3 = 0 ;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 PyObject * obj2 = 0 ;
33876 char * kwnames[] = {
33877 (char *) "self",(char *) "width",(char *) "height", NULL
33878 };
33879
33880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33882 if (!SWIG_IsOK(res1)) {
33883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33884 }
33885 arg1 = reinterpret_cast< wxWindow * >(argp1);
33886 ecode2 = SWIG_AsVal_int(obj1, &val2);
33887 if (!SWIG_IsOK(ecode2)) {
33888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33889 }
33890 arg2 = static_cast< int >(val2);
33891 ecode3 = SWIG_AsVal_int(obj2, &val3);
33892 if (!SWIG_IsOK(ecode3)) {
33893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33894 }
33895 arg3 = static_cast< int >(val3);
33896 {
33897 PyThreadState* __tstate = wxPyBeginAllowThreads();
33898 (arg1)->SetSize(arg2,arg3);
33899 wxPyEndAllowThreads(__tstate);
33900 if (PyErr_Occurred()) SWIG_fail;
33901 }
33902 resultobj = SWIG_Py_Void();
33903 return resultobj;
33904 fail:
33905 return NULL;
33906 }
33907
33908
33909 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33910 PyObject *resultobj = 0;
33911 wxWindow *arg1 = (wxWindow *) 0 ;
33912 wxPoint *arg2 = 0 ;
33913 int arg3 = (int) wxSIZE_USE_EXISTING ;
33914 void *argp1 = 0 ;
33915 int res1 = 0 ;
33916 wxPoint temp2 ;
33917 int val3 ;
33918 int ecode3 = 0 ;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 PyObject * obj2 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "pt",(char *) "flags", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33930 }
33931 arg1 = reinterpret_cast< wxWindow * >(argp1);
33932 {
33933 arg2 = &temp2;
33934 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33935 }
33936 if (obj2) {
33937 ecode3 = SWIG_AsVal_int(obj2, &val3);
33938 if (!SWIG_IsOK(ecode3)) {
33939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33940 }
33941 arg3 = static_cast< int >(val3);
33942 }
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 (arg1)->Move((wxPoint const &)*arg2,arg3);
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 resultobj = SWIG_Py_Void();
33950 return resultobj;
33951 fail:
33952 return NULL;
33953 }
33954
33955
33956 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33957 PyObject *resultobj = 0;
33958 wxWindow *arg1 = (wxWindow *) 0 ;
33959 int arg2 ;
33960 int arg3 ;
33961 int arg4 = (int) wxSIZE_USE_EXISTING ;
33962 void *argp1 = 0 ;
33963 int res1 = 0 ;
33964 int val2 ;
33965 int ecode2 = 0 ;
33966 int val3 ;
33967 int ecode3 = 0 ;
33968 int val4 ;
33969 int ecode4 = 0 ;
33970 PyObject * obj0 = 0 ;
33971 PyObject * obj1 = 0 ;
33972 PyObject * obj2 = 0 ;
33973 PyObject * obj3 = 0 ;
33974 char * kwnames[] = {
33975 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33976 };
33977
33978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33980 if (!SWIG_IsOK(res1)) {
33981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33982 }
33983 arg1 = reinterpret_cast< wxWindow * >(argp1);
33984 ecode2 = SWIG_AsVal_int(obj1, &val2);
33985 if (!SWIG_IsOK(ecode2)) {
33986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33987 }
33988 arg2 = static_cast< int >(val2);
33989 ecode3 = SWIG_AsVal_int(obj2, &val3);
33990 if (!SWIG_IsOK(ecode3)) {
33991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33992 }
33993 arg3 = static_cast< int >(val3);
33994 if (obj3) {
33995 ecode4 = SWIG_AsVal_int(obj3, &val4);
33996 if (!SWIG_IsOK(ecode4)) {
33997 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33998 }
33999 arg4 = static_cast< int >(val4);
34000 }
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 (arg1)->Move(arg2,arg3,arg4);
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 resultobj = SWIG_Py_Void();
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34015 PyObject *resultobj = 0;
34016 wxWindow *arg1 = (wxWindow *) 0 ;
34017 wxSize const &arg2_defvalue = wxDefaultSize ;
34018 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34019 void *argp1 = 0 ;
34020 int res1 = 0 ;
34021 wxSize temp2 ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "size", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34032 }
34033 arg1 = reinterpret_cast< wxWindow * >(argp1);
34034 if (obj1) {
34035 {
34036 arg2 = &temp2;
34037 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34038 }
34039 }
34040 {
34041 PyThreadState* __tstate = wxPyBeginAllowThreads();
34042 (arg1)->SetInitialSize((wxSize const &)*arg2);
34043 wxPyEndAllowThreads(__tstate);
34044 if (PyErr_Occurred()) SWIG_fail;
34045 }
34046 resultobj = SWIG_Py_Void();
34047 return resultobj;
34048 fail:
34049 return NULL;
34050 }
34051
34052
34053 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34054 PyObject *resultobj = 0;
34055 wxWindow *arg1 = (wxWindow *) 0 ;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 PyObject *swig_obj[1] ;
34059
34060 if (!args) SWIG_fail;
34061 swig_obj[0] = args;
34062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34065 }
34066 arg1 = reinterpret_cast< wxWindow * >(argp1);
34067 {
34068 PyThreadState* __tstate = wxPyBeginAllowThreads();
34069 (arg1)->Raise();
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 resultobj = SWIG_Py_Void();
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34081 PyObject *resultobj = 0;
34082 wxWindow *arg1 = (wxWindow *) 0 ;
34083 void *argp1 = 0 ;
34084 int res1 = 0 ;
34085 PyObject *swig_obj[1] ;
34086
34087 if (!args) SWIG_fail;
34088 swig_obj[0] = args;
34089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34090 if (!SWIG_IsOK(res1)) {
34091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34092 }
34093 arg1 = reinterpret_cast< wxWindow * >(argp1);
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 (arg1)->Lower();
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_Py_Void();
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxSize *arg2 = 0 ;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 wxSize temp2 ;
34114 PyObject * obj0 = 0 ;
34115 PyObject * obj1 = 0 ;
34116 char * kwnames[] = {
34117 (char *) "self",(char *) "size", NULL
34118 };
34119
34120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34122 if (!SWIG_IsOK(res1)) {
34123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34124 }
34125 arg1 = reinterpret_cast< wxWindow * >(argp1);
34126 {
34127 arg2 = &temp2;
34128 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34129 }
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 (arg1)->SetClientSize((wxSize const &)*arg2);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_Py_Void();
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34144 PyObject *resultobj = 0;
34145 wxWindow *arg1 = (wxWindow *) 0 ;
34146 int arg2 ;
34147 int arg3 ;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 int val2 ;
34151 int ecode2 = 0 ;
34152 int val3 ;
34153 int ecode3 = 0 ;
34154 PyObject * obj0 = 0 ;
34155 PyObject * obj1 = 0 ;
34156 PyObject * obj2 = 0 ;
34157 char * kwnames[] = {
34158 (char *) "self",(char *) "width",(char *) "height", NULL
34159 };
34160
34161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34163 if (!SWIG_IsOK(res1)) {
34164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34165 }
34166 arg1 = reinterpret_cast< wxWindow * >(argp1);
34167 ecode2 = SWIG_AsVal_int(obj1, &val2);
34168 if (!SWIG_IsOK(ecode2)) {
34169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34170 }
34171 arg2 = static_cast< int >(val2);
34172 ecode3 = SWIG_AsVal_int(obj2, &val3);
34173 if (!SWIG_IsOK(ecode3)) {
34174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34175 }
34176 arg3 = static_cast< int >(val3);
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 (arg1)->SetClientSize(arg2,arg3);
34180 wxPyEndAllowThreads(__tstate);
34181 if (PyErr_Occurred()) SWIG_fail;
34182 }
34183 resultobj = SWIG_Py_Void();
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34191 PyObject *resultobj = 0;
34192 wxWindow *arg1 = (wxWindow *) 0 ;
34193 wxRect *arg2 = 0 ;
34194 void *argp1 = 0 ;
34195 int res1 = 0 ;
34196 wxRect temp2 ;
34197 PyObject * obj0 = 0 ;
34198 PyObject * obj1 = 0 ;
34199 char * kwnames[] = {
34200 (char *) "self",(char *) "rect", NULL
34201 };
34202
34203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34205 if (!SWIG_IsOK(res1)) {
34206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34207 }
34208 arg1 = reinterpret_cast< wxWindow * >(argp1);
34209 {
34210 arg2 = &temp2;
34211 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34212 }
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 (arg1)->SetClientSize((wxRect const &)*arg2);
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 resultobj = SWIG_Py_Void();
34220 return resultobj;
34221 fail:
34222 return NULL;
34223 }
34224
34225
34226 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34227 PyObject *resultobj = 0;
34228 wxWindow *arg1 = (wxWindow *) 0 ;
34229 wxPoint result;
34230 void *argp1 = 0 ;
34231 int res1 = 0 ;
34232 PyObject *swig_obj[1] ;
34233
34234 if (!args) SWIG_fail;
34235 swig_obj[0] = args;
34236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34237 if (!SWIG_IsOK(res1)) {
34238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34239 }
34240 arg1 = reinterpret_cast< wxWindow * >(argp1);
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 result = ((wxWindow const *)arg1)->GetPosition();
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34255 PyObject *resultobj = 0;
34256 wxWindow *arg1 = (wxWindow *) 0 ;
34257 int *arg2 = (int *) 0 ;
34258 int *arg3 = (int *) 0 ;
34259 void *argp1 = 0 ;
34260 int res1 = 0 ;
34261 int temp2 ;
34262 int res2 = SWIG_TMPOBJ ;
34263 int temp3 ;
34264 int res3 = SWIG_TMPOBJ ;
34265 PyObject *swig_obj[1] ;
34266
34267 arg2 = &temp2;
34268 arg3 = &temp3;
34269 if (!args) SWIG_fail;
34270 swig_obj[0] = args;
34271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34272 if (!SWIG_IsOK(res1)) {
34273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34274 }
34275 arg1 = reinterpret_cast< wxWindow * >(argp1);
34276 {
34277 PyThreadState* __tstate = wxPyBeginAllowThreads();
34278 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34279 wxPyEndAllowThreads(__tstate);
34280 if (PyErr_Occurred()) SWIG_fail;
34281 }
34282 resultobj = SWIG_Py_Void();
34283 if (SWIG_IsTmpObj(res2)) {
34284 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34285 } else {
34286 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34287 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34288 }
34289 if (SWIG_IsTmpObj(res3)) {
34290 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34291 } else {
34292 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34294 }
34295 return resultobj;
34296 fail:
34297 return NULL;
34298 }
34299
34300
34301 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34302 PyObject *resultobj = 0;
34303 wxWindow *arg1 = (wxWindow *) 0 ;
34304 wxPoint result;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 PyObject *swig_obj[1] ;
34308
34309 if (!args) SWIG_fail;
34310 swig_obj[0] = args;
34311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34312 if (!SWIG_IsOK(res1)) {
34313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34314 }
34315 arg1 = reinterpret_cast< wxWindow * >(argp1);
34316 {
34317 PyThreadState* __tstate = wxPyBeginAllowThreads();
34318 result = ((wxWindow const *)arg1)->GetScreenPosition();
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34330 PyObject *resultobj = 0;
34331 wxWindow *arg1 = (wxWindow *) 0 ;
34332 int *arg2 = (int *) 0 ;
34333 int *arg3 = (int *) 0 ;
34334 void *argp1 = 0 ;
34335 int res1 = 0 ;
34336 int temp2 ;
34337 int res2 = SWIG_TMPOBJ ;
34338 int temp3 ;
34339 int res3 = SWIG_TMPOBJ ;
34340 PyObject *swig_obj[1] ;
34341
34342 arg2 = &temp2;
34343 arg3 = &temp3;
34344 if (!args) SWIG_fail;
34345 swig_obj[0] = args;
34346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34347 if (!SWIG_IsOK(res1)) {
34348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34349 }
34350 arg1 = reinterpret_cast< wxWindow * >(argp1);
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34354 wxPyEndAllowThreads(__tstate);
34355 if (PyErr_Occurred()) SWIG_fail;
34356 }
34357 resultobj = SWIG_Py_Void();
34358 if (SWIG_IsTmpObj(res2)) {
34359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34360 } else {
34361 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34363 }
34364 if (SWIG_IsTmpObj(res3)) {
34365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34366 } else {
34367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34369 }
34370 return resultobj;
34371 fail:
34372 return NULL;
34373 }
34374
34375
34376 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34377 PyObject *resultobj = 0;
34378 wxWindow *arg1 = (wxWindow *) 0 ;
34379 wxRect result;
34380 void *argp1 = 0 ;
34381 int res1 = 0 ;
34382 PyObject *swig_obj[1] ;
34383
34384 if (!args) SWIG_fail;
34385 swig_obj[0] = args;
34386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34387 if (!SWIG_IsOK(res1)) {
34388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34389 }
34390 arg1 = reinterpret_cast< wxWindow * >(argp1);
34391 {
34392 PyThreadState* __tstate = wxPyBeginAllowThreads();
34393 result = ((wxWindow const *)arg1)->GetScreenRect();
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34398 return resultobj;
34399 fail:
34400 return NULL;
34401 }
34402
34403
34404 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34405 PyObject *resultobj = 0;
34406 wxWindow *arg1 = (wxWindow *) 0 ;
34407 wxSize result;
34408 void *argp1 = 0 ;
34409 int res1 = 0 ;
34410 PyObject *swig_obj[1] ;
34411
34412 if (!args) SWIG_fail;
34413 swig_obj[0] = args;
34414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34415 if (!SWIG_IsOK(res1)) {
34416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34417 }
34418 arg1 = reinterpret_cast< wxWindow * >(argp1);
34419 {
34420 PyThreadState* __tstate = wxPyBeginAllowThreads();
34421 result = ((wxWindow const *)arg1)->GetSize();
34422 wxPyEndAllowThreads(__tstate);
34423 if (PyErr_Occurred()) SWIG_fail;
34424 }
34425 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34433 PyObject *resultobj = 0;
34434 wxWindow *arg1 = (wxWindow *) 0 ;
34435 int *arg2 = (int *) 0 ;
34436 int *arg3 = (int *) 0 ;
34437 void *argp1 = 0 ;
34438 int res1 = 0 ;
34439 int temp2 ;
34440 int res2 = SWIG_TMPOBJ ;
34441 int temp3 ;
34442 int res3 = SWIG_TMPOBJ ;
34443 PyObject *swig_obj[1] ;
34444
34445 arg2 = &temp2;
34446 arg3 = &temp3;
34447 if (!args) SWIG_fail;
34448 swig_obj[0] = args;
34449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34450 if (!SWIG_IsOK(res1)) {
34451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34452 }
34453 arg1 = reinterpret_cast< wxWindow * >(argp1);
34454 {
34455 PyThreadState* __tstate = wxPyBeginAllowThreads();
34456 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34457 wxPyEndAllowThreads(__tstate);
34458 if (PyErr_Occurred()) SWIG_fail;
34459 }
34460 resultobj = SWIG_Py_Void();
34461 if (SWIG_IsTmpObj(res2)) {
34462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34463 } else {
34464 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34466 }
34467 if (SWIG_IsTmpObj(res3)) {
34468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34469 } else {
34470 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34472 }
34473 return resultobj;
34474 fail:
34475 return NULL;
34476 }
34477
34478
34479 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34480 PyObject *resultobj = 0;
34481 wxWindow *arg1 = (wxWindow *) 0 ;
34482 wxRect result;
34483 void *argp1 = 0 ;
34484 int res1 = 0 ;
34485 PyObject *swig_obj[1] ;
34486
34487 if (!args) SWIG_fail;
34488 swig_obj[0] = args;
34489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34492 }
34493 arg1 = reinterpret_cast< wxWindow * >(argp1);
34494 {
34495 PyThreadState* __tstate = wxPyBeginAllowThreads();
34496 result = ((wxWindow const *)arg1)->GetRect();
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34501 return resultobj;
34502 fail:
34503 return NULL;
34504 }
34505
34506
34507 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34508 PyObject *resultobj = 0;
34509 wxWindow *arg1 = (wxWindow *) 0 ;
34510 wxSize result;
34511 void *argp1 = 0 ;
34512 int res1 = 0 ;
34513 PyObject *swig_obj[1] ;
34514
34515 if (!args) SWIG_fail;
34516 swig_obj[0] = args;
34517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34518 if (!SWIG_IsOK(res1)) {
34519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34520 }
34521 arg1 = reinterpret_cast< wxWindow * >(argp1);
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 result = ((wxWindow const *)arg1)->GetClientSize();
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34529 return resultobj;
34530 fail:
34531 return NULL;
34532 }
34533
34534
34535 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34536 PyObject *resultobj = 0;
34537 wxWindow *arg1 = (wxWindow *) 0 ;
34538 int *arg2 = (int *) 0 ;
34539 int *arg3 = (int *) 0 ;
34540 void *argp1 = 0 ;
34541 int res1 = 0 ;
34542 int temp2 ;
34543 int res2 = SWIG_TMPOBJ ;
34544 int temp3 ;
34545 int res3 = SWIG_TMPOBJ ;
34546 PyObject *swig_obj[1] ;
34547
34548 arg2 = &temp2;
34549 arg3 = &temp3;
34550 if (!args) SWIG_fail;
34551 swig_obj[0] = args;
34552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34555 }
34556 arg1 = reinterpret_cast< wxWindow * >(argp1);
34557 {
34558 PyThreadState* __tstate = wxPyBeginAllowThreads();
34559 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34560 wxPyEndAllowThreads(__tstate);
34561 if (PyErr_Occurred()) SWIG_fail;
34562 }
34563 resultobj = SWIG_Py_Void();
34564 if (SWIG_IsTmpObj(res2)) {
34565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34566 } else {
34567 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34569 }
34570 if (SWIG_IsTmpObj(res3)) {
34571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34572 } else {
34573 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34575 }
34576 return resultobj;
34577 fail:
34578 return NULL;
34579 }
34580
34581
34582 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34583 PyObject *resultobj = 0;
34584 wxWindow *arg1 = (wxWindow *) 0 ;
34585 wxPoint result;
34586 void *argp1 = 0 ;
34587 int res1 = 0 ;
34588 PyObject *swig_obj[1] ;
34589
34590 if (!args) SWIG_fail;
34591 swig_obj[0] = args;
34592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34593 if (!SWIG_IsOK(res1)) {
34594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34595 }
34596 arg1 = reinterpret_cast< wxWindow * >(argp1);
34597 {
34598 PyThreadState* __tstate = wxPyBeginAllowThreads();
34599 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34611 PyObject *resultobj = 0;
34612 wxWindow *arg1 = (wxWindow *) 0 ;
34613 wxRect result;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 PyObject *swig_obj[1] ;
34617
34618 if (!args) SWIG_fail;
34619 swig_obj[0] = args;
34620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34621 if (!SWIG_IsOK(res1)) {
34622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34623 }
34624 arg1 = reinterpret_cast< wxWindow * >(argp1);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = ((wxWindow const *)arg1)->GetClientRect();
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34639 PyObject *resultobj = 0;
34640 wxWindow *arg1 = (wxWindow *) 0 ;
34641 wxSize result;
34642 void *argp1 = 0 ;
34643 int res1 = 0 ;
34644 PyObject *swig_obj[1] ;
34645
34646 if (!args) SWIG_fail;
34647 swig_obj[0] = args;
34648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34649 if (!SWIG_IsOK(res1)) {
34650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34651 }
34652 arg1 = reinterpret_cast< wxWindow * >(argp1);
34653 {
34654 PyThreadState* __tstate = wxPyBeginAllowThreads();
34655 result = ((wxWindow const *)arg1)->GetBestSize();
34656 wxPyEndAllowThreads(__tstate);
34657 if (PyErr_Occurred()) SWIG_fail;
34658 }
34659 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34660 return resultobj;
34661 fail:
34662 return NULL;
34663 }
34664
34665
34666 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34667 PyObject *resultobj = 0;
34668 wxWindow *arg1 = (wxWindow *) 0 ;
34669 int *arg2 = (int *) 0 ;
34670 int *arg3 = (int *) 0 ;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 int temp2 ;
34674 int res2 = SWIG_TMPOBJ ;
34675 int temp3 ;
34676 int res3 = SWIG_TMPOBJ ;
34677 PyObject *swig_obj[1] ;
34678
34679 arg2 = &temp2;
34680 arg3 = &temp3;
34681 if (!args) SWIG_fail;
34682 swig_obj[0] = args;
34683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34684 if (!SWIG_IsOK(res1)) {
34685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34686 }
34687 arg1 = reinterpret_cast< wxWindow * >(argp1);
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34691 wxPyEndAllowThreads(__tstate);
34692 if (PyErr_Occurred()) SWIG_fail;
34693 }
34694 resultobj = SWIG_Py_Void();
34695 if (SWIG_IsTmpObj(res2)) {
34696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34697 } else {
34698 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34700 }
34701 if (SWIG_IsTmpObj(res3)) {
34702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34703 } else {
34704 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34706 }
34707 return resultobj;
34708 fail:
34709 return NULL;
34710 }
34711
34712
34713 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34714 PyObject *resultobj = 0;
34715 wxWindow *arg1 = (wxWindow *) 0 ;
34716 void *argp1 = 0 ;
34717 int res1 = 0 ;
34718 PyObject *swig_obj[1] ;
34719
34720 if (!args) SWIG_fail;
34721 swig_obj[0] = args;
34722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34723 if (!SWIG_IsOK(res1)) {
34724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34725 }
34726 arg1 = reinterpret_cast< wxWindow * >(argp1);
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 (arg1)->InvalidateBestSize();
34730 wxPyEndAllowThreads(__tstate);
34731 if (PyErr_Occurred()) SWIG_fail;
34732 }
34733 resultobj = SWIG_Py_Void();
34734 return resultobj;
34735 fail:
34736 return NULL;
34737 }
34738
34739
34740 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34741 PyObject *resultobj = 0;
34742 wxWindow *arg1 = (wxWindow *) 0 ;
34743 wxSize *arg2 = 0 ;
34744 void *argp1 = 0 ;
34745 int res1 = 0 ;
34746 wxSize temp2 ;
34747 PyObject * obj0 = 0 ;
34748 PyObject * obj1 = 0 ;
34749 char * kwnames[] = {
34750 (char *) "self",(char *) "size", NULL
34751 };
34752
34753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34755 if (!SWIG_IsOK(res1)) {
34756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34757 }
34758 arg1 = reinterpret_cast< wxWindow * >(argp1);
34759 {
34760 arg2 = &temp2;
34761 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34762 }
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34766 wxPyEndAllowThreads(__tstate);
34767 if (PyErr_Occurred()) SWIG_fail;
34768 }
34769 resultobj = SWIG_Py_Void();
34770 return resultobj;
34771 fail:
34772 return NULL;
34773 }
34774
34775
34776 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34777 PyObject *resultobj = 0;
34778 wxWindow *arg1 = (wxWindow *) 0 ;
34779 wxSize result;
34780 void *argp1 = 0 ;
34781 int res1 = 0 ;
34782 PyObject *swig_obj[1] ;
34783
34784 if (!args) SWIG_fail;
34785 swig_obj[0] = args;
34786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34787 if (!SWIG_IsOK(res1)) {
34788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34789 }
34790 arg1 = reinterpret_cast< wxWindow * >(argp1);
34791 {
34792 PyThreadState* __tstate = wxPyBeginAllowThreads();
34793 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34798 return resultobj;
34799 fail:
34800 return NULL;
34801 }
34802
34803
34804 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34805 PyObject *resultobj = 0;
34806 wxWindow *arg1 = (wxWindow *) 0 ;
34807 int arg2 = (int) wxBOTH ;
34808 void *argp1 = 0 ;
34809 int res1 = 0 ;
34810 int val2 ;
34811 int ecode2 = 0 ;
34812 PyObject * obj0 = 0 ;
34813 PyObject * obj1 = 0 ;
34814 char * kwnames[] = {
34815 (char *) "self",(char *) "direction", NULL
34816 };
34817
34818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34820 if (!SWIG_IsOK(res1)) {
34821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34822 }
34823 arg1 = reinterpret_cast< wxWindow * >(argp1);
34824 if (obj1) {
34825 ecode2 = SWIG_AsVal_int(obj1, &val2);
34826 if (!SWIG_IsOK(ecode2)) {
34827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34828 }
34829 arg2 = static_cast< int >(val2);
34830 }
34831 {
34832 PyThreadState* __tstate = wxPyBeginAllowThreads();
34833 (arg1)->Center(arg2);
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 resultobj = SWIG_Py_Void();
34838 return resultobj;
34839 fail:
34840 return NULL;
34841 }
34842
34843
34844 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34845 PyObject *resultobj = 0;
34846 wxWindow *arg1 = (wxWindow *) 0 ;
34847 int arg2 = (int) wxBOTH ;
34848 void *argp1 = 0 ;
34849 int res1 = 0 ;
34850 int val2 ;
34851 int ecode2 = 0 ;
34852 PyObject * obj0 = 0 ;
34853 PyObject * obj1 = 0 ;
34854 char * kwnames[] = {
34855 (char *) "self",(char *) "dir", NULL
34856 };
34857
34858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34860 if (!SWIG_IsOK(res1)) {
34861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34862 }
34863 arg1 = reinterpret_cast< wxWindow * >(argp1);
34864 if (obj1) {
34865 ecode2 = SWIG_AsVal_int(obj1, &val2);
34866 if (!SWIG_IsOK(ecode2)) {
34867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34868 }
34869 arg2 = static_cast< int >(val2);
34870 }
34871 {
34872 PyThreadState* __tstate = wxPyBeginAllowThreads();
34873 (arg1)->CenterOnParent(arg2);
34874 wxPyEndAllowThreads(__tstate);
34875 if (PyErr_Occurred()) SWIG_fail;
34876 }
34877 resultobj = SWIG_Py_Void();
34878 return resultobj;
34879 fail:
34880 return NULL;
34881 }
34882
34883
34884 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34885 PyObject *resultobj = 0;
34886 wxWindow *arg1 = (wxWindow *) 0 ;
34887 void *argp1 = 0 ;
34888 int res1 = 0 ;
34889 PyObject *swig_obj[1] ;
34890
34891 if (!args) SWIG_fail;
34892 swig_obj[0] = args;
34893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34894 if (!SWIG_IsOK(res1)) {
34895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34896 }
34897 arg1 = reinterpret_cast< wxWindow * >(argp1);
34898 {
34899 PyThreadState* __tstate = wxPyBeginAllowThreads();
34900 (arg1)->Fit();
34901 wxPyEndAllowThreads(__tstate);
34902 if (PyErr_Occurred()) SWIG_fail;
34903 }
34904 resultobj = SWIG_Py_Void();
34905 return resultobj;
34906 fail:
34907 return NULL;
34908 }
34909
34910
34911 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34912 PyObject *resultobj = 0;
34913 wxWindow *arg1 = (wxWindow *) 0 ;
34914 void *argp1 = 0 ;
34915 int res1 = 0 ;
34916 PyObject *swig_obj[1] ;
34917
34918 if (!args) SWIG_fail;
34919 swig_obj[0] = args;
34920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34921 if (!SWIG_IsOK(res1)) {
34922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34923 }
34924 arg1 = reinterpret_cast< wxWindow * >(argp1);
34925 {
34926 PyThreadState* __tstate = wxPyBeginAllowThreads();
34927 (arg1)->FitInside();
34928 wxPyEndAllowThreads(__tstate);
34929 if (PyErr_Occurred()) SWIG_fail;
34930 }
34931 resultobj = SWIG_Py_Void();
34932 return resultobj;
34933 fail:
34934 return NULL;
34935 }
34936
34937
34938 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34939 PyObject *resultobj = 0;
34940 wxWindow *arg1 = (wxWindow *) 0 ;
34941 int arg2 ;
34942 int arg3 ;
34943 int arg4 = (int) -1 ;
34944 int arg5 = (int) -1 ;
34945 int arg6 = (int) -1 ;
34946 int arg7 = (int) -1 ;
34947 void *argp1 = 0 ;
34948 int res1 = 0 ;
34949 int val2 ;
34950 int ecode2 = 0 ;
34951 int val3 ;
34952 int ecode3 = 0 ;
34953 int val4 ;
34954 int ecode4 = 0 ;
34955 int val5 ;
34956 int ecode5 = 0 ;
34957 int val6 ;
34958 int ecode6 = 0 ;
34959 int val7 ;
34960 int ecode7 = 0 ;
34961 PyObject * obj0 = 0 ;
34962 PyObject * obj1 = 0 ;
34963 PyObject * obj2 = 0 ;
34964 PyObject * obj3 = 0 ;
34965 PyObject * obj4 = 0 ;
34966 PyObject * obj5 = 0 ;
34967 PyObject * obj6 = 0 ;
34968 char * kwnames[] = {
34969 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34970 };
34971
34972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34974 if (!SWIG_IsOK(res1)) {
34975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34976 }
34977 arg1 = reinterpret_cast< wxWindow * >(argp1);
34978 ecode2 = SWIG_AsVal_int(obj1, &val2);
34979 if (!SWIG_IsOK(ecode2)) {
34980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34981 }
34982 arg2 = static_cast< int >(val2);
34983 ecode3 = SWIG_AsVal_int(obj2, &val3);
34984 if (!SWIG_IsOK(ecode3)) {
34985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34986 }
34987 arg3 = static_cast< int >(val3);
34988 if (obj3) {
34989 ecode4 = SWIG_AsVal_int(obj3, &val4);
34990 if (!SWIG_IsOK(ecode4)) {
34991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34992 }
34993 arg4 = static_cast< int >(val4);
34994 }
34995 if (obj4) {
34996 ecode5 = SWIG_AsVal_int(obj4, &val5);
34997 if (!SWIG_IsOK(ecode5)) {
34998 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34999 }
35000 arg5 = static_cast< int >(val5);
35001 }
35002 if (obj5) {
35003 ecode6 = SWIG_AsVal_int(obj5, &val6);
35004 if (!SWIG_IsOK(ecode6)) {
35005 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35006 }
35007 arg6 = static_cast< int >(val6);
35008 }
35009 if (obj6) {
35010 ecode7 = SWIG_AsVal_int(obj6, &val7);
35011 if (!SWIG_IsOK(ecode7)) {
35012 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35013 }
35014 arg7 = static_cast< int >(val7);
35015 }
35016 {
35017 PyThreadState* __tstate = wxPyBeginAllowThreads();
35018 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35019 wxPyEndAllowThreads(__tstate);
35020 if (PyErr_Occurred()) SWIG_fail;
35021 }
35022 resultobj = SWIG_Py_Void();
35023 return resultobj;
35024 fail:
35025 return NULL;
35026 }
35027
35028
35029 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35030 PyObject *resultobj = 0;
35031 wxWindow *arg1 = (wxWindow *) 0 ;
35032 wxSize *arg2 = 0 ;
35033 wxSize const &arg3_defvalue = wxDefaultSize ;
35034 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35035 wxSize const &arg4_defvalue = wxDefaultSize ;
35036 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35037 void *argp1 = 0 ;
35038 int res1 = 0 ;
35039 wxSize temp2 ;
35040 wxSize temp3 ;
35041 wxSize temp4 ;
35042 PyObject * obj0 = 0 ;
35043 PyObject * obj1 = 0 ;
35044 PyObject * obj2 = 0 ;
35045 PyObject * obj3 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 {
35057 arg2 = &temp2;
35058 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35059 }
35060 if (obj2) {
35061 {
35062 arg3 = &temp3;
35063 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35064 }
35065 }
35066 if (obj3) {
35067 {
35068 arg4 = &temp4;
35069 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35070 }
35071 }
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 resultobj = SWIG_Py_Void();
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 int arg2 ;
35089 int arg3 ;
35090 int arg4 = (int) -1 ;
35091 int arg5 = (int) -1 ;
35092 void *argp1 = 0 ;
35093 int res1 = 0 ;
35094 int val2 ;
35095 int ecode2 = 0 ;
35096 int val3 ;
35097 int ecode3 = 0 ;
35098 int val4 ;
35099 int ecode4 = 0 ;
35100 int val5 ;
35101 int ecode5 = 0 ;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 PyObject * obj2 = 0 ;
35105 PyObject * obj3 = 0 ;
35106 PyObject * obj4 = 0 ;
35107 char * kwnames[] = {
35108 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35109 };
35110
35111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35113 if (!SWIG_IsOK(res1)) {
35114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35115 }
35116 arg1 = reinterpret_cast< wxWindow * >(argp1);
35117 ecode2 = SWIG_AsVal_int(obj1, &val2);
35118 if (!SWIG_IsOK(ecode2)) {
35119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35120 }
35121 arg2 = static_cast< int >(val2);
35122 ecode3 = SWIG_AsVal_int(obj2, &val3);
35123 if (!SWIG_IsOK(ecode3)) {
35124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35125 }
35126 arg3 = static_cast< int >(val3);
35127 if (obj3) {
35128 ecode4 = SWIG_AsVal_int(obj3, &val4);
35129 if (!SWIG_IsOK(ecode4)) {
35130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35131 }
35132 arg4 = static_cast< int >(val4);
35133 }
35134 if (obj4) {
35135 ecode5 = SWIG_AsVal_int(obj4, &val5);
35136 if (!SWIG_IsOK(ecode5)) {
35137 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35138 }
35139 arg5 = static_cast< int >(val5);
35140 }
35141 {
35142 PyThreadState* __tstate = wxPyBeginAllowThreads();
35143 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35144 wxPyEndAllowThreads(__tstate);
35145 if (PyErr_Occurred()) SWIG_fail;
35146 }
35147 resultobj = SWIG_Py_Void();
35148 return resultobj;
35149 fail:
35150 return NULL;
35151 }
35152
35153
35154 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35155 PyObject *resultobj = 0;
35156 wxWindow *arg1 = (wxWindow *) 0 ;
35157 wxSize *arg2 = 0 ;
35158 wxSize const &arg3_defvalue = wxDefaultSize ;
35159 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 wxSize temp2 ;
35163 wxSize temp3 ;
35164 PyObject * obj0 = 0 ;
35165 PyObject * obj1 = 0 ;
35166 PyObject * obj2 = 0 ;
35167 char * kwnames[] = {
35168 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35169 };
35170
35171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35173 if (!SWIG_IsOK(res1)) {
35174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35175 }
35176 arg1 = reinterpret_cast< wxWindow * >(argp1);
35177 {
35178 arg2 = &temp2;
35179 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35180 }
35181 if (obj2) {
35182 {
35183 arg3 = &temp3;
35184 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35185 }
35186 }
35187 {
35188 PyThreadState* __tstate = wxPyBeginAllowThreads();
35189 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35190 wxPyEndAllowThreads(__tstate);
35191 if (PyErr_Occurred()) SWIG_fail;
35192 }
35193 resultobj = SWIG_Py_Void();
35194 return resultobj;
35195 fail:
35196 return NULL;
35197 }
35198
35199
35200 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35201 PyObject *resultobj = 0;
35202 wxWindow *arg1 = (wxWindow *) 0 ;
35203 wxSize result;
35204 void *argp1 = 0 ;
35205 int res1 = 0 ;
35206 PyObject *swig_obj[1] ;
35207
35208 if (!args) SWIG_fail;
35209 swig_obj[0] = args;
35210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35211 if (!SWIG_IsOK(res1)) {
35212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35213 }
35214 arg1 = reinterpret_cast< wxWindow * >(argp1);
35215 {
35216 PyThreadState* __tstate = wxPyBeginAllowThreads();
35217 result = ((wxWindow const *)arg1)->GetMaxSize();
35218 wxPyEndAllowThreads(__tstate);
35219 if (PyErr_Occurred()) SWIG_fail;
35220 }
35221 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35222 return resultobj;
35223 fail:
35224 return NULL;
35225 }
35226
35227
35228 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35229 PyObject *resultobj = 0;
35230 wxWindow *arg1 = (wxWindow *) 0 ;
35231 wxSize result;
35232 void *argp1 = 0 ;
35233 int res1 = 0 ;
35234 PyObject *swig_obj[1] ;
35235
35236 if (!args) SWIG_fail;
35237 swig_obj[0] = args;
35238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35239 if (!SWIG_IsOK(res1)) {
35240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35241 }
35242 arg1 = reinterpret_cast< wxWindow * >(argp1);
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 result = ((wxWindow const *)arg1)->GetMinSize();
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35257 PyObject *resultobj = 0;
35258 wxWindow *arg1 = (wxWindow *) 0 ;
35259 wxSize *arg2 = 0 ;
35260 void *argp1 = 0 ;
35261 int res1 = 0 ;
35262 wxSize temp2 ;
35263 PyObject * obj0 = 0 ;
35264 PyObject * obj1 = 0 ;
35265 char * kwnames[] = {
35266 (char *) "self",(char *) "minSize", NULL
35267 };
35268
35269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35271 if (!SWIG_IsOK(res1)) {
35272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35273 }
35274 arg1 = reinterpret_cast< wxWindow * >(argp1);
35275 {
35276 arg2 = &temp2;
35277 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35278 }
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 (arg1)->SetMinSize((wxSize const &)*arg2);
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 resultobj = SWIG_Py_Void();
35286 return resultobj;
35287 fail:
35288 return NULL;
35289 }
35290
35291
35292 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35293 PyObject *resultobj = 0;
35294 wxWindow *arg1 = (wxWindow *) 0 ;
35295 wxSize *arg2 = 0 ;
35296 void *argp1 = 0 ;
35297 int res1 = 0 ;
35298 wxSize temp2 ;
35299 PyObject * obj0 = 0 ;
35300 PyObject * obj1 = 0 ;
35301 char * kwnames[] = {
35302 (char *) "self",(char *) "maxSize", NULL
35303 };
35304
35305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35307 if (!SWIG_IsOK(res1)) {
35308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35309 }
35310 arg1 = reinterpret_cast< wxWindow * >(argp1);
35311 {
35312 arg2 = &temp2;
35313 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35314 }
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 (arg1)->SetMaxSize((wxSize const &)*arg2);
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 resultobj = SWIG_Py_Void();
35322 return resultobj;
35323 fail:
35324 return NULL;
35325 }
35326
35327
35328 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35329 PyObject *resultobj = 0;
35330 wxWindow *arg1 = (wxWindow *) 0 ;
35331 int result;
35332 void *argp1 = 0 ;
35333 int res1 = 0 ;
35334 PyObject *swig_obj[1] ;
35335
35336 if (!args) SWIG_fail;
35337 swig_obj[0] = args;
35338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35339 if (!SWIG_IsOK(res1)) {
35340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35341 }
35342 arg1 = reinterpret_cast< wxWindow * >(argp1);
35343 {
35344 PyThreadState* __tstate = wxPyBeginAllowThreads();
35345 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35346 wxPyEndAllowThreads(__tstate);
35347 if (PyErr_Occurred()) SWIG_fail;
35348 }
35349 resultobj = SWIG_From_int(static_cast< int >(result));
35350 return resultobj;
35351 fail:
35352 return NULL;
35353 }
35354
35355
35356 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35357 PyObject *resultobj = 0;
35358 wxWindow *arg1 = (wxWindow *) 0 ;
35359 int result;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 PyObject *swig_obj[1] ;
35363
35364 if (!args) SWIG_fail;
35365 swig_obj[0] = args;
35366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35367 if (!SWIG_IsOK(res1)) {
35368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35369 }
35370 arg1 = reinterpret_cast< wxWindow * >(argp1);
35371 {
35372 PyThreadState* __tstate = wxPyBeginAllowThreads();
35373 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35374 wxPyEndAllowThreads(__tstate);
35375 if (PyErr_Occurred()) SWIG_fail;
35376 }
35377 resultobj = SWIG_From_int(static_cast< int >(result));
35378 return resultobj;
35379 fail:
35380 return NULL;
35381 }
35382
35383
35384 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35385 PyObject *resultobj = 0;
35386 wxWindow *arg1 = (wxWindow *) 0 ;
35387 int result;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 PyObject *swig_obj[1] ;
35391
35392 if (!args) SWIG_fail;
35393 swig_obj[0] = args;
35394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35395 if (!SWIG_IsOK(res1)) {
35396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35397 }
35398 arg1 = reinterpret_cast< wxWindow * >(argp1);
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 resultobj = SWIG_From_int(static_cast< int >(result));
35406 return resultobj;
35407 fail:
35408 return NULL;
35409 }
35410
35411
35412 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35413 PyObject *resultobj = 0;
35414 wxWindow *arg1 = (wxWindow *) 0 ;
35415 int result;
35416 void *argp1 = 0 ;
35417 int res1 = 0 ;
35418 PyObject *swig_obj[1] ;
35419
35420 if (!args) SWIG_fail;
35421 swig_obj[0] = args;
35422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35423 if (!SWIG_IsOK(res1)) {
35424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35425 }
35426 arg1 = reinterpret_cast< wxWindow * >(argp1);
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35430 wxPyEndAllowThreads(__tstate);
35431 if (PyErr_Occurred()) SWIG_fail;
35432 }
35433 resultobj = SWIG_From_int(static_cast< int >(result));
35434 return resultobj;
35435 fail:
35436 return NULL;
35437 }
35438
35439
35440 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35441 PyObject *resultobj = 0;
35442 wxWindow *arg1 = (wxWindow *) 0 ;
35443 wxSize *arg2 = 0 ;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 wxSize temp2 ;
35447 PyObject * obj0 = 0 ;
35448 PyObject * obj1 = 0 ;
35449 char * kwnames[] = {
35450 (char *) "self",(char *) "size", NULL
35451 };
35452
35453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35455 if (!SWIG_IsOK(res1)) {
35456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35457 }
35458 arg1 = reinterpret_cast< wxWindow * >(argp1);
35459 {
35460 arg2 = &temp2;
35461 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35462 }
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35466 wxPyEndAllowThreads(__tstate);
35467 if (PyErr_Occurred()) SWIG_fail;
35468 }
35469 resultobj = SWIG_Py_Void();
35470 return resultobj;
35471 fail:
35472 return NULL;
35473 }
35474
35475
35476 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35477 PyObject *resultobj = 0;
35478 wxWindow *arg1 = (wxWindow *) 0 ;
35479 int arg2 ;
35480 int arg3 ;
35481 void *argp1 = 0 ;
35482 int res1 = 0 ;
35483 int val2 ;
35484 int ecode2 = 0 ;
35485 int val3 ;
35486 int ecode3 = 0 ;
35487 PyObject * obj0 = 0 ;
35488 PyObject * obj1 = 0 ;
35489 PyObject * obj2 = 0 ;
35490 char * kwnames[] = {
35491 (char *) "self",(char *) "w",(char *) "h", NULL
35492 };
35493
35494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35496 if (!SWIG_IsOK(res1)) {
35497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35498 }
35499 arg1 = reinterpret_cast< wxWindow * >(argp1);
35500 ecode2 = SWIG_AsVal_int(obj1, &val2);
35501 if (!SWIG_IsOK(ecode2)) {
35502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35503 }
35504 arg2 = static_cast< int >(val2);
35505 ecode3 = SWIG_AsVal_int(obj2, &val3);
35506 if (!SWIG_IsOK(ecode3)) {
35507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35508 }
35509 arg3 = static_cast< int >(val3);
35510 {
35511 PyThreadState* __tstate = wxPyBeginAllowThreads();
35512 (arg1)->SetVirtualSize(arg2,arg3);
35513 wxPyEndAllowThreads(__tstate);
35514 if (PyErr_Occurred()) SWIG_fail;
35515 }
35516 resultobj = SWIG_Py_Void();
35517 return resultobj;
35518 fail:
35519 return NULL;
35520 }
35521
35522
35523 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35524 PyObject *resultobj = 0;
35525 wxWindow *arg1 = (wxWindow *) 0 ;
35526 wxSize result;
35527 void *argp1 = 0 ;
35528 int res1 = 0 ;
35529 PyObject *swig_obj[1] ;
35530
35531 if (!args) SWIG_fail;
35532 swig_obj[0] = args;
35533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35534 if (!SWIG_IsOK(res1)) {
35535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35536 }
35537 arg1 = reinterpret_cast< wxWindow * >(argp1);
35538 {
35539 PyThreadState* __tstate = wxPyBeginAllowThreads();
35540 result = ((wxWindow const *)arg1)->GetVirtualSize();
35541 wxPyEndAllowThreads(__tstate);
35542 if (PyErr_Occurred()) SWIG_fail;
35543 }
35544 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35545 return resultobj;
35546 fail:
35547 return NULL;
35548 }
35549
35550
35551 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35552 PyObject *resultobj = 0;
35553 wxWindow *arg1 = (wxWindow *) 0 ;
35554 int *arg2 = (int *) 0 ;
35555 int *arg3 = (int *) 0 ;
35556 void *argp1 = 0 ;
35557 int res1 = 0 ;
35558 int temp2 ;
35559 int res2 = SWIG_TMPOBJ ;
35560 int temp3 ;
35561 int res3 = SWIG_TMPOBJ ;
35562 PyObject *swig_obj[1] ;
35563
35564 arg2 = &temp2;
35565 arg3 = &temp3;
35566 if (!args) SWIG_fail;
35567 swig_obj[0] = args;
35568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35569 if (!SWIG_IsOK(res1)) {
35570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35571 }
35572 arg1 = reinterpret_cast< wxWindow * >(argp1);
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 resultobj = SWIG_Py_Void();
35580 if (SWIG_IsTmpObj(res2)) {
35581 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35582 } else {
35583 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35585 }
35586 if (SWIG_IsTmpObj(res3)) {
35587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35588 } else {
35589 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35591 }
35592 return resultobj;
35593 fail:
35594 return NULL;
35595 }
35596
35597
35598 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35599 PyObject *resultobj = 0;
35600 wxWindow *arg1 = (wxWindow *) 0 ;
35601 wxSize result;
35602 void *argp1 = 0 ;
35603 int res1 = 0 ;
35604 PyObject *swig_obj[1] ;
35605
35606 if (!args) SWIG_fail;
35607 swig_obj[0] = args;
35608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35609 if (!SWIG_IsOK(res1)) {
35610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35611 }
35612 arg1 = reinterpret_cast< wxWindow * >(argp1);
35613 {
35614 PyThreadState* __tstate = wxPyBeginAllowThreads();
35615 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35616 wxPyEndAllowThreads(__tstate);
35617 if (PyErr_Occurred()) SWIG_fail;
35618 }
35619 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35620 return resultobj;
35621 fail:
35622 return NULL;
35623 }
35624
35625
35626 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35627 PyObject *resultobj = 0;
35628 wxWindow *arg1 = (wxWindow *) 0 ;
35629 wxSize result;
35630 void *argp1 = 0 ;
35631 int res1 = 0 ;
35632 PyObject *swig_obj[1] ;
35633
35634 if (!args) SWIG_fail;
35635 swig_obj[0] = args;
35636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35637 if (!SWIG_IsOK(res1)) {
35638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35639 }
35640 arg1 = reinterpret_cast< wxWindow * >(argp1);
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35655 PyObject *resultobj = 0;
35656 wxWindow *arg1 = (wxWindow *) 0 ;
35657 bool arg2 = (bool) true ;
35658 bool result;
35659 void *argp1 = 0 ;
35660 int res1 = 0 ;
35661 bool val2 ;
35662 int ecode2 = 0 ;
35663 PyObject * obj0 = 0 ;
35664 PyObject * obj1 = 0 ;
35665 char * kwnames[] = {
35666 (char *) "self",(char *) "show", NULL
35667 };
35668
35669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35673 }
35674 arg1 = reinterpret_cast< wxWindow * >(argp1);
35675 if (obj1) {
35676 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35677 if (!SWIG_IsOK(ecode2)) {
35678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35679 }
35680 arg2 = static_cast< bool >(val2);
35681 }
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 result = (bool)(arg1)->Show(arg2);
35685 wxPyEndAllowThreads(__tstate);
35686 if (PyErr_Occurred()) SWIG_fail;
35687 }
35688 {
35689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35690 }
35691 return resultobj;
35692 fail:
35693 return NULL;
35694 }
35695
35696
35697 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35698 PyObject *resultobj = 0;
35699 wxWindow *arg1 = (wxWindow *) 0 ;
35700 bool result;
35701 void *argp1 = 0 ;
35702 int res1 = 0 ;
35703 PyObject *swig_obj[1] ;
35704
35705 if (!args) SWIG_fail;
35706 swig_obj[0] = args;
35707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35708 if (!SWIG_IsOK(res1)) {
35709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35710 }
35711 arg1 = reinterpret_cast< wxWindow * >(argp1);
35712 {
35713 PyThreadState* __tstate = wxPyBeginAllowThreads();
35714 result = (bool)(arg1)->Hide();
35715 wxPyEndAllowThreads(__tstate);
35716 if (PyErr_Occurred()) SWIG_fail;
35717 }
35718 {
35719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35720 }
35721 return resultobj;
35722 fail:
35723 return NULL;
35724 }
35725
35726
35727 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35728 PyObject *resultobj = 0;
35729 wxWindow *arg1 = (wxWindow *) 0 ;
35730 bool arg2 = (bool) true ;
35731 bool result;
35732 void *argp1 = 0 ;
35733 int res1 = 0 ;
35734 bool val2 ;
35735 int ecode2 = 0 ;
35736 PyObject * obj0 = 0 ;
35737 PyObject * obj1 = 0 ;
35738 char * kwnames[] = {
35739 (char *) "self",(char *) "enable", NULL
35740 };
35741
35742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35744 if (!SWIG_IsOK(res1)) {
35745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35746 }
35747 arg1 = reinterpret_cast< wxWindow * >(argp1);
35748 if (obj1) {
35749 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35750 if (!SWIG_IsOK(ecode2)) {
35751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35752 }
35753 arg2 = static_cast< bool >(val2);
35754 }
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = (bool)(arg1)->Enable(arg2);
35758 wxPyEndAllowThreads(__tstate);
35759 if (PyErr_Occurred()) SWIG_fail;
35760 }
35761 {
35762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35763 }
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35771 PyObject *resultobj = 0;
35772 wxWindow *arg1 = (wxWindow *) 0 ;
35773 bool result;
35774 void *argp1 = 0 ;
35775 int res1 = 0 ;
35776 PyObject *swig_obj[1] ;
35777
35778 if (!args) SWIG_fail;
35779 swig_obj[0] = args;
35780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35781 if (!SWIG_IsOK(res1)) {
35782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35783 }
35784 arg1 = reinterpret_cast< wxWindow * >(argp1);
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = (bool)(arg1)->Disable();
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 {
35792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35793 }
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35801 PyObject *resultobj = 0;
35802 wxWindow *arg1 = (wxWindow *) 0 ;
35803 bool result;
35804 void *argp1 = 0 ;
35805 int res1 = 0 ;
35806 PyObject *swig_obj[1] ;
35807
35808 if (!args) SWIG_fail;
35809 swig_obj[0] = args;
35810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35811 if (!SWIG_IsOK(res1)) {
35812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35813 }
35814 arg1 = reinterpret_cast< wxWindow * >(argp1);
35815 {
35816 PyThreadState* __tstate = wxPyBeginAllowThreads();
35817 result = (bool)((wxWindow const *)arg1)->IsShown();
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 {
35822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35823 }
35824 return resultobj;
35825 fail:
35826 return NULL;
35827 }
35828
35829
35830 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35831 PyObject *resultobj = 0;
35832 wxWindow *arg1 = (wxWindow *) 0 ;
35833 bool result;
35834 void *argp1 = 0 ;
35835 int res1 = 0 ;
35836 PyObject *swig_obj[1] ;
35837
35838 if (!args) SWIG_fail;
35839 swig_obj[0] = args;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 {
35852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35853 }
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35861 PyObject *resultobj = 0;
35862 wxWindow *arg1 = (wxWindow *) 0 ;
35863 bool result;
35864 void *argp1 = 0 ;
35865 int res1 = 0 ;
35866 PyObject *swig_obj[1] ;
35867
35868 if (!args) SWIG_fail;
35869 swig_obj[0] = args;
35870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 {
35882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35883 }
35884 return resultobj;
35885 fail:
35886 return NULL;
35887 }
35888
35889
35890 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35891 PyObject *resultobj = 0;
35892 wxWindow *arg1 = (wxWindow *) 0 ;
35893 bool result;
35894 void *argp1 = 0 ;
35895 int res1 = 0 ;
35896 PyObject *swig_obj[1] ;
35897
35898 if (!args) SWIG_fail;
35899 swig_obj[0] = args;
35900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35901 if (!SWIG_IsOK(res1)) {
35902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35903 }
35904 arg1 = reinterpret_cast< wxWindow * >(argp1);
35905 {
35906 PyThreadState* __tstate = wxPyBeginAllowThreads();
35907 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35908 wxPyEndAllowThreads(__tstate);
35909 if (PyErr_Occurred()) SWIG_fail;
35910 }
35911 {
35912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35913 }
35914 return resultobj;
35915 fail:
35916 return NULL;
35917 }
35918
35919
35920 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35921 PyObject *resultobj = 0;
35922 wxWindow *arg1 = (wxWindow *) 0 ;
35923 long arg2 ;
35924 void *argp1 = 0 ;
35925 int res1 = 0 ;
35926 long val2 ;
35927 int ecode2 = 0 ;
35928 PyObject * obj0 = 0 ;
35929 PyObject * obj1 = 0 ;
35930 char * kwnames[] = {
35931 (char *) "self",(char *) "style", NULL
35932 };
35933
35934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35936 if (!SWIG_IsOK(res1)) {
35937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35938 }
35939 arg1 = reinterpret_cast< wxWindow * >(argp1);
35940 ecode2 = SWIG_AsVal_long(obj1, &val2);
35941 if (!SWIG_IsOK(ecode2)) {
35942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35943 }
35944 arg2 = static_cast< long >(val2);
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 (arg1)->SetWindowStyleFlag(arg2);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 resultobj = SWIG_Py_Void();
35952 return resultobj;
35953 fail:
35954 return NULL;
35955 }
35956
35957
35958 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35959 PyObject *resultobj = 0;
35960 wxWindow *arg1 = (wxWindow *) 0 ;
35961 long result;
35962 void *argp1 = 0 ;
35963 int res1 = 0 ;
35964 PyObject *swig_obj[1] ;
35965
35966 if (!args) SWIG_fail;
35967 swig_obj[0] = args;
35968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35969 if (!SWIG_IsOK(res1)) {
35970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35971 }
35972 arg1 = reinterpret_cast< wxWindow * >(argp1);
35973 {
35974 PyThreadState* __tstate = wxPyBeginAllowThreads();
35975 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 resultobj = SWIG_From_long(static_cast< long >(result));
35980 return resultobj;
35981 fail:
35982 return NULL;
35983 }
35984
35985
35986 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35987 PyObject *resultobj = 0;
35988 wxWindow *arg1 = (wxWindow *) 0 ;
35989 int arg2 ;
35990 bool result;
35991 void *argp1 = 0 ;
35992 int res1 = 0 ;
35993 int val2 ;
35994 int ecode2 = 0 ;
35995 PyObject * obj0 = 0 ;
35996 PyObject * obj1 = 0 ;
35997 char * kwnames[] = {
35998 (char *) "self",(char *) "flag", NULL
35999 };
36000
36001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36003 if (!SWIG_IsOK(res1)) {
36004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36005 }
36006 arg1 = reinterpret_cast< wxWindow * >(argp1);
36007 ecode2 = SWIG_AsVal_int(obj1, &val2);
36008 if (!SWIG_IsOK(ecode2)) {
36009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36010 }
36011 arg2 = static_cast< int >(val2);
36012 {
36013 PyThreadState* __tstate = wxPyBeginAllowThreads();
36014 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 {
36019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36020 }
36021 return resultobj;
36022 fail:
36023 return NULL;
36024 }
36025
36026
36027 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36028 PyObject *resultobj = 0;
36029 wxWindow *arg1 = (wxWindow *) 0 ;
36030 bool result;
36031 void *argp1 = 0 ;
36032 int res1 = 0 ;
36033 PyObject *swig_obj[1] ;
36034
36035 if (!args) SWIG_fail;
36036 swig_obj[0] = args;
36037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36038 if (!SWIG_IsOK(res1)) {
36039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36040 }
36041 arg1 = reinterpret_cast< wxWindow * >(argp1);
36042 {
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 result = (bool)((wxWindow const *)arg1)->IsRetained();
36045 wxPyEndAllowThreads(__tstate);
36046 if (PyErr_Occurred()) SWIG_fail;
36047 }
36048 {
36049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36050 }
36051 return resultobj;
36052 fail:
36053 return NULL;
36054 }
36055
36056
36057 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36058 PyObject *resultobj = 0;
36059 wxWindow *arg1 = (wxWindow *) 0 ;
36060 int arg2 ;
36061 bool result;
36062 void *argp1 = 0 ;
36063 int res1 = 0 ;
36064 int val2 ;
36065 int ecode2 = 0 ;
36066 PyObject * obj0 = 0 ;
36067 PyObject * obj1 = 0 ;
36068 char * kwnames[] = {
36069 (char *) "self",(char *) "flag", NULL
36070 };
36071
36072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36074 if (!SWIG_IsOK(res1)) {
36075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36076 }
36077 arg1 = reinterpret_cast< wxWindow * >(argp1);
36078 ecode2 = SWIG_AsVal_int(obj1, &val2);
36079 if (!SWIG_IsOK(ecode2)) {
36080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36081 }
36082 arg2 = static_cast< int >(val2);
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36086 wxPyEndAllowThreads(__tstate);
36087 if (PyErr_Occurred()) SWIG_fail;
36088 }
36089 {
36090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36091 }
36092 return resultobj;
36093 fail:
36094 return NULL;
36095 }
36096
36097
36098 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36099 PyObject *resultobj = 0;
36100 wxWindow *arg1 = (wxWindow *) 0 ;
36101 long arg2 ;
36102 void *argp1 = 0 ;
36103 int res1 = 0 ;
36104 long val2 ;
36105 int ecode2 = 0 ;
36106 PyObject * obj0 = 0 ;
36107 PyObject * obj1 = 0 ;
36108 char * kwnames[] = {
36109 (char *) "self",(char *) "exStyle", NULL
36110 };
36111
36112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36114 if (!SWIG_IsOK(res1)) {
36115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36116 }
36117 arg1 = reinterpret_cast< wxWindow * >(argp1);
36118 ecode2 = SWIG_AsVal_long(obj1, &val2);
36119 if (!SWIG_IsOK(ecode2)) {
36120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36121 }
36122 arg2 = static_cast< long >(val2);
36123 {
36124 PyThreadState* __tstate = wxPyBeginAllowThreads();
36125 (arg1)->SetExtraStyle(arg2);
36126 wxPyEndAllowThreads(__tstate);
36127 if (PyErr_Occurred()) SWIG_fail;
36128 }
36129 resultobj = SWIG_Py_Void();
36130 return resultobj;
36131 fail:
36132 return NULL;
36133 }
36134
36135
36136 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36137 PyObject *resultobj = 0;
36138 wxWindow *arg1 = (wxWindow *) 0 ;
36139 long result;
36140 void *argp1 = 0 ;
36141 int res1 = 0 ;
36142 PyObject *swig_obj[1] ;
36143
36144 if (!args) SWIG_fail;
36145 swig_obj[0] = args;
36146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36147 if (!SWIG_IsOK(res1)) {
36148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36149 }
36150 arg1 = reinterpret_cast< wxWindow * >(argp1);
36151 {
36152 PyThreadState* __tstate = wxPyBeginAllowThreads();
36153 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36154 wxPyEndAllowThreads(__tstate);
36155 if (PyErr_Occurred()) SWIG_fail;
36156 }
36157 resultobj = SWIG_From_long(static_cast< long >(result));
36158 return resultobj;
36159 fail:
36160 return NULL;
36161 }
36162
36163
36164 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36165 PyObject *resultobj = 0;
36166 wxWindow *arg1 = (wxWindow *) 0 ;
36167 bool arg2 = (bool) true ;
36168 void *argp1 = 0 ;
36169 int res1 = 0 ;
36170 bool val2 ;
36171 int ecode2 = 0 ;
36172 PyObject * obj0 = 0 ;
36173 PyObject * obj1 = 0 ;
36174 char * kwnames[] = {
36175 (char *) "self",(char *) "modal", NULL
36176 };
36177
36178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 if (obj1) {
36185 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36186 if (!SWIG_IsOK(ecode2)) {
36187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36188 }
36189 arg2 = static_cast< bool >(val2);
36190 }
36191 {
36192 PyThreadState* __tstate = wxPyBeginAllowThreads();
36193 (arg1)->MakeModal(arg2);
36194 wxPyEndAllowThreads(__tstate);
36195 if (PyErr_Occurred()) SWIG_fail;
36196 }
36197 resultobj = SWIG_Py_Void();
36198 return resultobj;
36199 fail:
36200 return NULL;
36201 }
36202
36203
36204 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36205 PyObject *resultobj = 0;
36206 wxWindow *arg1 = (wxWindow *) 0 ;
36207 bool arg2 ;
36208 void *argp1 = 0 ;
36209 int res1 = 0 ;
36210 bool val2 ;
36211 int ecode2 = 0 ;
36212 PyObject * obj0 = 0 ;
36213 PyObject * obj1 = 0 ;
36214 char * kwnames[] = {
36215 (char *) "self",(char *) "enableTheme", NULL
36216 };
36217
36218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36220 if (!SWIG_IsOK(res1)) {
36221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36222 }
36223 arg1 = reinterpret_cast< wxWindow * >(argp1);
36224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36225 if (!SWIG_IsOK(ecode2)) {
36226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36227 }
36228 arg2 = static_cast< bool >(val2);
36229 {
36230 PyThreadState* __tstate = wxPyBeginAllowThreads();
36231 (arg1)->SetThemeEnabled(arg2);
36232 wxPyEndAllowThreads(__tstate);
36233 if (PyErr_Occurred()) SWIG_fail;
36234 }
36235 resultobj = SWIG_Py_Void();
36236 return resultobj;
36237 fail:
36238 return NULL;
36239 }
36240
36241
36242 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36243 PyObject *resultobj = 0;
36244 wxWindow *arg1 = (wxWindow *) 0 ;
36245 bool result;
36246 void *argp1 = 0 ;
36247 int res1 = 0 ;
36248 PyObject *swig_obj[1] ;
36249
36250 if (!args) SWIG_fail;
36251 swig_obj[0] = args;
36252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36253 if (!SWIG_IsOK(res1)) {
36254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36255 }
36256 arg1 = reinterpret_cast< wxWindow * >(argp1);
36257 {
36258 PyThreadState* __tstate = wxPyBeginAllowThreads();
36259 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36260 wxPyEndAllowThreads(__tstate);
36261 if (PyErr_Occurred()) SWIG_fail;
36262 }
36263 {
36264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36265 }
36266 return resultobj;
36267 fail:
36268 return NULL;
36269 }
36270
36271
36272 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36273 PyObject *resultobj = 0;
36274 wxWindow *arg1 = (wxWindow *) 0 ;
36275 void *argp1 = 0 ;
36276 int res1 = 0 ;
36277 PyObject *swig_obj[1] ;
36278
36279 if (!args) SWIG_fail;
36280 swig_obj[0] = args;
36281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36282 if (!SWIG_IsOK(res1)) {
36283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36284 }
36285 arg1 = reinterpret_cast< wxWindow * >(argp1);
36286 {
36287 PyThreadState* __tstate = wxPyBeginAllowThreads();
36288 (arg1)->SetFocus();
36289 wxPyEndAllowThreads(__tstate);
36290 if (PyErr_Occurred()) SWIG_fail;
36291 }
36292 resultobj = SWIG_Py_Void();
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36300 PyObject *resultobj = 0;
36301 wxWindow *arg1 = (wxWindow *) 0 ;
36302 void *argp1 = 0 ;
36303 int res1 = 0 ;
36304 PyObject *swig_obj[1] ;
36305
36306 if (!args) SWIG_fail;
36307 swig_obj[0] = args;
36308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36309 if (!SWIG_IsOK(res1)) {
36310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36311 }
36312 arg1 = reinterpret_cast< wxWindow * >(argp1);
36313 {
36314 PyThreadState* __tstate = wxPyBeginAllowThreads();
36315 (arg1)->SetFocusFromKbd();
36316 wxPyEndAllowThreads(__tstate);
36317 if (PyErr_Occurred()) SWIG_fail;
36318 }
36319 resultobj = SWIG_Py_Void();
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36327 PyObject *resultobj = 0;
36328 wxWindow *result = 0 ;
36329
36330 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36331 {
36332 if (!wxPyCheckForApp()) SWIG_fail;
36333 PyThreadState* __tstate = wxPyBeginAllowThreads();
36334 result = (wxWindow *)wxWindow::FindFocus();
36335 wxPyEndAllowThreads(__tstate);
36336 if (PyErr_Occurred()) SWIG_fail;
36337 }
36338 {
36339 resultobj = wxPyMake_wxObject(result, 0);
36340 }
36341 return resultobj;
36342 fail:
36343 return NULL;
36344 }
36345
36346
36347 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36348 PyObject *resultobj = 0;
36349 wxWindow *arg1 = (wxWindow *) 0 ;
36350 bool result;
36351 void *argp1 = 0 ;
36352 int res1 = 0 ;
36353 PyObject *swig_obj[1] ;
36354
36355 if (!args) SWIG_fail;
36356 swig_obj[0] = args;
36357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36358 if (!SWIG_IsOK(res1)) {
36359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36360 }
36361 arg1 = reinterpret_cast< wxWindow * >(argp1);
36362 {
36363 PyThreadState* __tstate = wxPyBeginAllowThreads();
36364 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36365 wxPyEndAllowThreads(__tstate);
36366 if (PyErr_Occurred()) SWIG_fail;
36367 }
36368 {
36369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36370 }
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36378 PyObject *resultobj = 0;
36379 wxWindow *arg1 = (wxWindow *) 0 ;
36380 bool result;
36381 void *argp1 = 0 ;
36382 int res1 = 0 ;
36383 PyObject *swig_obj[1] ;
36384
36385 if (!args) SWIG_fail;
36386 swig_obj[0] = args;
36387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36388 if (!SWIG_IsOK(res1)) {
36389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36390 }
36391 arg1 = reinterpret_cast< wxWindow * >(argp1);
36392 {
36393 PyThreadState* __tstate = wxPyBeginAllowThreads();
36394 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36395 wxPyEndAllowThreads(__tstate);
36396 if (PyErr_Occurred()) SWIG_fail;
36397 }
36398 {
36399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36400 }
36401 return resultobj;
36402 fail:
36403 return NULL;
36404 }
36405
36406
36407 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36408 PyObject *resultobj = 0;
36409 wxWindow *arg1 = (wxWindow *) 0 ;
36410 bool result;
36411 void *argp1 = 0 ;
36412 int res1 = 0 ;
36413 PyObject *swig_obj[1] ;
36414
36415 if (!args) SWIG_fail;
36416 swig_obj[0] = args;
36417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36418 if (!SWIG_IsOK(res1)) {
36419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36420 }
36421 arg1 = reinterpret_cast< wxWindow * >(argp1);
36422 {
36423 PyThreadState* __tstate = wxPyBeginAllowThreads();
36424 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 {
36429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36430 }
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36438 PyObject *resultobj = 0;
36439 wxWindow *arg1 = (wxWindow *) 0 ;
36440 bool result;
36441 void *argp1 = 0 ;
36442 int res1 = 0 ;
36443 PyObject *swig_obj[1] ;
36444
36445 if (!args) SWIG_fail;
36446 swig_obj[0] = args;
36447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36448 if (!SWIG_IsOK(res1)) {
36449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36450 }
36451 arg1 = reinterpret_cast< wxWindow * >(argp1);
36452 {
36453 PyThreadState* __tstate = wxPyBeginAllowThreads();
36454 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36455 wxPyEndAllowThreads(__tstate);
36456 if (PyErr_Occurred()) SWIG_fail;
36457 }
36458 {
36459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36460 }
36461 return resultobj;
36462 fail:
36463 return NULL;
36464 }
36465
36466
36467 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36468 PyObject *resultobj = 0;
36469 wxWindow *arg1 = (wxWindow *) 0 ;
36470 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36471 bool result;
36472 void *argp1 = 0 ;
36473 int res1 = 0 ;
36474 int val2 ;
36475 int ecode2 = 0 ;
36476 PyObject * obj0 = 0 ;
36477 PyObject * obj1 = 0 ;
36478 char * kwnames[] = {
36479 (char *) "self",(char *) "flags", NULL
36480 };
36481
36482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36484 if (!SWIG_IsOK(res1)) {
36485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36486 }
36487 arg1 = reinterpret_cast< wxWindow * >(argp1);
36488 if (obj1) {
36489 ecode2 = SWIG_AsVal_int(obj1, &val2);
36490 if (!SWIG_IsOK(ecode2)) {
36491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36492 }
36493 arg2 = static_cast< int >(val2);
36494 }
36495 {
36496 PyThreadState* __tstate = wxPyBeginAllowThreads();
36497 result = (bool)(arg1)->Navigate(arg2);
36498 wxPyEndAllowThreads(__tstate);
36499 if (PyErr_Occurred()) SWIG_fail;
36500 }
36501 {
36502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36503 }
36504 return resultobj;
36505 fail:
36506 return NULL;
36507 }
36508
36509
36510 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36511 PyObject *resultobj = 0;
36512 wxWindow *arg1 = (wxWindow *) 0 ;
36513 wxWindow *arg2 = (wxWindow *) 0 ;
36514 void *argp1 = 0 ;
36515 int res1 = 0 ;
36516 void *argp2 = 0 ;
36517 int res2 = 0 ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char * kwnames[] = {
36521 (char *) "self",(char *) "win", NULL
36522 };
36523
36524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",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_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36528 }
36529 arg1 = reinterpret_cast< wxWindow * >(argp1);
36530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36531 if (!SWIG_IsOK(res2)) {
36532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36533 }
36534 arg2 = reinterpret_cast< wxWindow * >(argp2);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 (arg1)->MoveAfterInTabOrder(arg2);
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 resultobj = SWIG_Py_Void();
36542 return resultobj;
36543 fail:
36544 return NULL;
36545 }
36546
36547
36548 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36549 PyObject *resultobj = 0;
36550 wxWindow *arg1 = (wxWindow *) 0 ;
36551 wxWindow *arg2 = (wxWindow *) 0 ;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 void *argp2 = 0 ;
36555 int res2 = 0 ;
36556 PyObject * obj0 = 0 ;
36557 PyObject * obj1 = 0 ;
36558 char * kwnames[] = {
36559 (char *) "self",(char *) "win", NULL
36560 };
36561
36562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36564 if (!SWIG_IsOK(res1)) {
36565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36566 }
36567 arg1 = reinterpret_cast< wxWindow * >(argp1);
36568 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36569 if (!SWIG_IsOK(res2)) {
36570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36571 }
36572 arg2 = reinterpret_cast< wxWindow * >(argp2);
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 (arg1)->MoveBeforeInTabOrder(arg2);
36576 wxPyEndAllowThreads(__tstate);
36577 if (PyErr_Occurred()) SWIG_fail;
36578 }
36579 resultobj = SWIG_Py_Void();
36580 return resultobj;
36581 fail:
36582 return NULL;
36583 }
36584
36585
36586 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36587 PyObject *resultobj = 0;
36588 wxWindow *arg1 = (wxWindow *) 0 ;
36589 PyObject *result = 0 ;
36590 void *argp1 = 0 ;
36591 int res1 = 0 ;
36592 PyObject *swig_obj[1] ;
36593
36594 if (!args) SWIG_fail;
36595 swig_obj[0] = args;
36596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36597 if (!SWIG_IsOK(res1)) {
36598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36599 }
36600 arg1 = reinterpret_cast< wxWindow * >(argp1);
36601 {
36602 PyThreadState* __tstate = wxPyBeginAllowThreads();
36603 result = (PyObject *)wxWindow_GetChildren(arg1);
36604 wxPyEndAllowThreads(__tstate);
36605 if (PyErr_Occurred()) SWIG_fail;
36606 }
36607 resultobj = result;
36608 return resultobj;
36609 fail:
36610 return NULL;
36611 }
36612
36613
36614 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36615 PyObject *resultobj = 0;
36616 wxWindow *arg1 = (wxWindow *) 0 ;
36617 wxWindow *result = 0 ;
36618 void *argp1 = 0 ;
36619 int res1 = 0 ;
36620 PyObject *swig_obj[1] ;
36621
36622 if (!args) SWIG_fail;
36623 swig_obj[0] = args;
36624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36625 if (!SWIG_IsOK(res1)) {
36626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36627 }
36628 arg1 = reinterpret_cast< wxWindow * >(argp1);
36629 {
36630 PyThreadState* __tstate = wxPyBeginAllowThreads();
36631 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36632 wxPyEndAllowThreads(__tstate);
36633 if (PyErr_Occurred()) SWIG_fail;
36634 }
36635 {
36636 resultobj = wxPyMake_wxObject(result, 0);
36637 }
36638 return resultobj;
36639 fail:
36640 return NULL;
36641 }
36642
36643
36644 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36645 PyObject *resultobj = 0;
36646 wxWindow *arg1 = (wxWindow *) 0 ;
36647 wxWindow *result = 0 ;
36648 void *argp1 = 0 ;
36649 int res1 = 0 ;
36650 PyObject *swig_obj[1] ;
36651
36652 if (!args) SWIG_fail;
36653 swig_obj[0] = args;
36654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36655 if (!SWIG_IsOK(res1)) {
36656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36657 }
36658 arg1 = reinterpret_cast< wxWindow * >(argp1);
36659 {
36660 PyThreadState* __tstate = wxPyBeginAllowThreads();
36661 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36662 wxPyEndAllowThreads(__tstate);
36663 if (PyErr_Occurred()) SWIG_fail;
36664 }
36665 {
36666 resultobj = wxPyMake_wxObject(result, 0);
36667 }
36668 return resultobj;
36669 fail:
36670 return NULL;
36671 }
36672
36673
36674 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36675 PyObject *resultobj = 0;
36676 wxWindow *arg1 = (wxWindow *) 0 ;
36677 wxWindow *result = 0 ;
36678 void *argp1 = 0 ;
36679 int res1 = 0 ;
36680 PyObject *swig_obj[1] ;
36681
36682 if (!args) SWIG_fail;
36683 swig_obj[0] = args;
36684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36685 if (!SWIG_IsOK(res1)) {
36686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
36687 }
36688 arg1 = reinterpret_cast< wxWindow * >(argp1);
36689 {
36690 PyThreadState* __tstate = wxPyBeginAllowThreads();
36691 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
36692 wxPyEndAllowThreads(__tstate);
36693 if (PyErr_Occurred()) SWIG_fail;
36694 }
36695 {
36696 resultobj = wxPyMake_wxObject(result, 0);
36697 }
36698 return resultobj;
36699 fail:
36700 return NULL;
36701 }
36702
36703
36704 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36705 PyObject *resultobj = 0;
36706 wxWindow *arg1 = (wxWindow *) 0 ;
36707 bool result;
36708 void *argp1 = 0 ;
36709 int res1 = 0 ;
36710 PyObject *swig_obj[1] ;
36711
36712 if (!args) SWIG_fail;
36713 swig_obj[0] = args;
36714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36715 if (!SWIG_IsOK(res1)) {
36716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36717 }
36718 arg1 = reinterpret_cast< wxWindow * >(argp1);
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36722 wxPyEndAllowThreads(__tstate);
36723 if (PyErr_Occurred()) SWIG_fail;
36724 }
36725 {
36726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36727 }
36728 return resultobj;
36729 fail:
36730 return NULL;
36731 }
36732
36733
36734 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36735 PyObject *resultobj = 0;
36736 wxWindow *arg1 = (wxWindow *) 0 ;
36737 wxWindow *arg2 = (wxWindow *) 0 ;
36738 bool result;
36739 void *argp1 = 0 ;
36740 int res1 = 0 ;
36741 void *argp2 = 0 ;
36742 int res2 = 0 ;
36743 PyObject * obj0 = 0 ;
36744 PyObject * obj1 = 0 ;
36745 char * kwnames[] = {
36746 (char *) "self",(char *) "newParent", NULL
36747 };
36748
36749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36751 if (!SWIG_IsOK(res1)) {
36752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36753 }
36754 arg1 = reinterpret_cast< wxWindow * >(argp1);
36755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36756 if (!SWIG_IsOK(res2)) {
36757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36758 }
36759 arg2 = reinterpret_cast< wxWindow * >(argp2);
36760 {
36761 PyThreadState* __tstate = wxPyBeginAllowThreads();
36762 result = (bool)(arg1)->Reparent(arg2);
36763 wxPyEndAllowThreads(__tstate);
36764 if (PyErr_Occurred()) SWIG_fail;
36765 }
36766 {
36767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36768 }
36769 return resultobj;
36770 fail:
36771 return NULL;
36772 }
36773
36774
36775 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36776 PyObject *resultobj = 0;
36777 wxWindow *arg1 = (wxWindow *) 0 ;
36778 wxWindow *arg2 = (wxWindow *) 0 ;
36779 void *argp1 = 0 ;
36780 int res1 = 0 ;
36781 void *argp2 = 0 ;
36782 int res2 = 0 ;
36783 PyObject * obj0 = 0 ;
36784 PyObject * obj1 = 0 ;
36785 char * kwnames[] = {
36786 (char *) "self",(char *) "child", NULL
36787 };
36788
36789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36791 if (!SWIG_IsOK(res1)) {
36792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36793 }
36794 arg1 = reinterpret_cast< wxWindow * >(argp1);
36795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36796 if (!SWIG_IsOK(res2)) {
36797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36798 }
36799 arg2 = reinterpret_cast< wxWindow * >(argp2);
36800 {
36801 PyThreadState* __tstate = wxPyBeginAllowThreads();
36802 (arg1)->AddChild(arg2);
36803 wxPyEndAllowThreads(__tstate);
36804 if (PyErr_Occurred()) SWIG_fail;
36805 }
36806 resultobj = SWIG_Py_Void();
36807 return resultobj;
36808 fail:
36809 return NULL;
36810 }
36811
36812
36813 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36814 PyObject *resultobj = 0;
36815 wxWindow *arg1 = (wxWindow *) 0 ;
36816 wxWindow *arg2 = (wxWindow *) 0 ;
36817 void *argp1 = 0 ;
36818 int res1 = 0 ;
36819 void *argp2 = 0 ;
36820 int res2 = 0 ;
36821 PyObject * obj0 = 0 ;
36822 PyObject * obj1 = 0 ;
36823 char * kwnames[] = {
36824 (char *) "self",(char *) "child", NULL
36825 };
36826
36827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36829 if (!SWIG_IsOK(res1)) {
36830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36831 }
36832 arg1 = reinterpret_cast< wxWindow * >(argp1);
36833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36834 if (!SWIG_IsOK(res2)) {
36835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36836 }
36837 arg2 = reinterpret_cast< wxWindow * >(argp2);
36838 {
36839 PyThreadState* __tstate = wxPyBeginAllowThreads();
36840 (arg1)->RemoveChild(arg2);
36841 wxPyEndAllowThreads(__tstate);
36842 if (PyErr_Occurred()) SWIG_fail;
36843 }
36844 resultobj = SWIG_Py_Void();
36845 return resultobj;
36846 fail:
36847 return NULL;
36848 }
36849
36850
36851 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36852 PyObject *resultobj = 0;
36853 wxWindow *arg1 = (wxWindow *) 0 ;
36854 bool arg2 ;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 bool val2 ;
36858 int ecode2 = 0 ;
36859 PyObject * obj0 = 0 ;
36860 PyObject * obj1 = 0 ;
36861 char * kwnames[] = {
36862 (char *) "self",(char *) "on", NULL
36863 };
36864
36865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36872 if (!SWIG_IsOK(ecode2)) {
36873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36874 }
36875 arg2 = static_cast< bool >(val2);
36876 {
36877 PyThreadState* __tstate = wxPyBeginAllowThreads();
36878 (arg1)->SetDoubleBuffered(arg2);
36879 wxPyEndAllowThreads(__tstate);
36880 if (PyErr_Occurred()) SWIG_fail;
36881 }
36882 resultobj = SWIG_Py_Void();
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36890 PyObject *resultobj = 0;
36891 wxWindow *arg1 = (wxWindow *) 0 ;
36892 long arg2 ;
36893 wxWindow *result = 0 ;
36894 void *argp1 = 0 ;
36895 int res1 = 0 ;
36896 long val2 ;
36897 int ecode2 = 0 ;
36898 PyObject * obj0 = 0 ;
36899 PyObject * obj1 = 0 ;
36900 char * kwnames[] = {
36901 (char *) "self",(char *) "winid", NULL
36902 };
36903
36904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36906 if (!SWIG_IsOK(res1)) {
36907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36908 }
36909 arg1 = reinterpret_cast< wxWindow * >(argp1);
36910 ecode2 = SWIG_AsVal_long(obj1, &val2);
36911 if (!SWIG_IsOK(ecode2)) {
36912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36913 }
36914 arg2 = static_cast< long >(val2);
36915 {
36916 PyThreadState* __tstate = wxPyBeginAllowThreads();
36917 result = (wxWindow *)(arg1)->FindWindow(arg2);
36918 wxPyEndAllowThreads(__tstate);
36919 if (PyErr_Occurred()) SWIG_fail;
36920 }
36921 {
36922 resultobj = wxPyMake_wxObject(result, 0);
36923 }
36924 return resultobj;
36925 fail:
36926 return NULL;
36927 }
36928
36929
36930 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36931 PyObject *resultobj = 0;
36932 wxWindow *arg1 = (wxWindow *) 0 ;
36933 wxString *arg2 = 0 ;
36934 wxWindow *result = 0 ;
36935 void *argp1 = 0 ;
36936 int res1 = 0 ;
36937 bool temp2 = false ;
36938 PyObject * obj0 = 0 ;
36939 PyObject * obj1 = 0 ;
36940 char * kwnames[] = {
36941 (char *) "self",(char *) "name", NULL
36942 };
36943
36944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36946 if (!SWIG_IsOK(res1)) {
36947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36948 }
36949 arg1 = reinterpret_cast< wxWindow * >(argp1);
36950 {
36951 arg2 = wxString_in_helper(obj1);
36952 if (arg2 == NULL) SWIG_fail;
36953 temp2 = true;
36954 }
36955 {
36956 PyThreadState* __tstate = wxPyBeginAllowThreads();
36957 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 {
36962 resultobj = wxPyMake_wxObject(result, 0);
36963 }
36964 {
36965 if (temp2)
36966 delete arg2;
36967 }
36968 return resultobj;
36969 fail:
36970 {
36971 if (temp2)
36972 delete arg2;
36973 }
36974 return NULL;
36975 }
36976
36977
36978 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36979 PyObject *resultobj = 0;
36980 wxWindow *arg1 = (wxWindow *) 0 ;
36981 wxEvtHandler *result = 0 ;
36982 void *argp1 = 0 ;
36983 int res1 = 0 ;
36984 PyObject *swig_obj[1] ;
36985
36986 if (!args) SWIG_fail;
36987 swig_obj[0] = args;
36988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36989 if (!SWIG_IsOK(res1)) {
36990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36991 }
36992 arg1 = reinterpret_cast< wxWindow * >(argp1);
36993 {
36994 PyThreadState* __tstate = wxPyBeginAllowThreads();
36995 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36996 wxPyEndAllowThreads(__tstate);
36997 if (PyErr_Occurred()) SWIG_fail;
36998 }
36999 {
37000 resultobj = wxPyMake_wxObject(result, 0);
37001 }
37002 return resultobj;
37003 fail:
37004 return NULL;
37005 }
37006
37007
37008 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37009 PyObject *resultobj = 0;
37010 wxWindow *arg1 = (wxWindow *) 0 ;
37011 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37012 void *argp1 = 0 ;
37013 int res1 = 0 ;
37014 void *argp2 = 0 ;
37015 int res2 = 0 ;
37016 PyObject * obj0 = 0 ;
37017 PyObject * obj1 = 0 ;
37018 char * kwnames[] = {
37019 (char *) "self",(char *) "handler", NULL
37020 };
37021
37022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37024 if (!SWIG_IsOK(res1)) {
37025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37026 }
37027 arg1 = reinterpret_cast< wxWindow * >(argp1);
37028 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37029 if (!SWIG_IsOK(res2)) {
37030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37031 }
37032 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37033 {
37034 PyThreadState* __tstate = wxPyBeginAllowThreads();
37035 (arg1)->SetEventHandler(arg2);
37036 wxPyEndAllowThreads(__tstate);
37037 if (PyErr_Occurred()) SWIG_fail;
37038 }
37039 resultobj = SWIG_Py_Void();
37040 return resultobj;
37041 fail:
37042 return NULL;
37043 }
37044
37045
37046 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37047 PyObject *resultobj = 0;
37048 wxWindow *arg1 = (wxWindow *) 0 ;
37049 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37050 void *argp1 = 0 ;
37051 int res1 = 0 ;
37052 void *argp2 = 0 ;
37053 int res2 = 0 ;
37054 PyObject * obj0 = 0 ;
37055 PyObject * obj1 = 0 ;
37056 char * kwnames[] = {
37057 (char *) "self",(char *) "handler", NULL
37058 };
37059
37060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37062 if (!SWIG_IsOK(res1)) {
37063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37064 }
37065 arg1 = reinterpret_cast< wxWindow * >(argp1);
37066 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37067 if (!SWIG_IsOK(res2)) {
37068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37069 }
37070 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37071 {
37072 PyThreadState* __tstate = wxPyBeginAllowThreads();
37073 (arg1)->PushEventHandler(arg2);
37074 wxPyEndAllowThreads(__tstate);
37075 if (PyErr_Occurred()) SWIG_fail;
37076 }
37077 resultobj = SWIG_Py_Void();
37078 return resultobj;
37079 fail:
37080 return NULL;
37081 }
37082
37083
37084 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37085 PyObject *resultobj = 0;
37086 wxWindow *arg1 = (wxWindow *) 0 ;
37087 bool arg2 = (bool) false ;
37088 wxEvtHandler *result = 0 ;
37089 void *argp1 = 0 ;
37090 int res1 = 0 ;
37091 bool val2 ;
37092 int ecode2 = 0 ;
37093 PyObject * obj0 = 0 ;
37094 PyObject * obj1 = 0 ;
37095 char * kwnames[] = {
37096 (char *) "self",(char *) "deleteHandler", NULL
37097 };
37098
37099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37101 if (!SWIG_IsOK(res1)) {
37102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37103 }
37104 arg1 = reinterpret_cast< wxWindow * >(argp1);
37105 if (obj1) {
37106 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37107 if (!SWIG_IsOK(ecode2)) {
37108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37109 }
37110 arg2 = static_cast< bool >(val2);
37111 }
37112 {
37113 PyThreadState* __tstate = wxPyBeginAllowThreads();
37114 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37115 wxPyEndAllowThreads(__tstate);
37116 if (PyErr_Occurred()) SWIG_fail;
37117 }
37118 {
37119 resultobj = wxPyMake_wxObject(result, 0);
37120 }
37121 return resultobj;
37122 fail:
37123 return NULL;
37124 }
37125
37126
37127 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37128 PyObject *resultobj = 0;
37129 wxWindow *arg1 = (wxWindow *) 0 ;
37130 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37131 bool result;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 void *argp2 = 0 ;
37135 int res2 = 0 ;
37136 PyObject * obj0 = 0 ;
37137 PyObject * obj1 = 0 ;
37138 char * kwnames[] = {
37139 (char *) "self",(char *) "handler", NULL
37140 };
37141
37142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37144 if (!SWIG_IsOK(res1)) {
37145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37146 }
37147 arg1 = reinterpret_cast< wxWindow * >(argp1);
37148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37149 if (!SWIG_IsOK(res2)) {
37150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37151 }
37152 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37153 {
37154 PyThreadState* __tstate = wxPyBeginAllowThreads();
37155 result = (bool)(arg1)->RemoveEventHandler(arg2);
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 {
37160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37161 }
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj = 0;
37170 wxWindow *arg1 = (wxWindow *) 0 ;
37171 wxValidator *arg2 = 0 ;
37172 void *argp1 = 0 ;
37173 int res1 = 0 ;
37174 void *argp2 = 0 ;
37175 int res2 = 0 ;
37176 PyObject * obj0 = 0 ;
37177 PyObject * obj1 = 0 ;
37178 char * kwnames[] = {
37179 (char *) "self",(char *) "validator", NULL
37180 };
37181
37182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37184 if (!SWIG_IsOK(res1)) {
37185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37186 }
37187 arg1 = reinterpret_cast< wxWindow * >(argp1);
37188 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37189 if (!SWIG_IsOK(res2)) {
37190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37191 }
37192 if (!argp2) {
37193 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37194 }
37195 arg2 = reinterpret_cast< wxValidator * >(argp2);
37196 {
37197 PyThreadState* __tstate = wxPyBeginAllowThreads();
37198 (arg1)->SetValidator((wxValidator const &)*arg2);
37199 wxPyEndAllowThreads(__tstate);
37200 if (PyErr_Occurred()) SWIG_fail;
37201 }
37202 resultobj = SWIG_Py_Void();
37203 return resultobj;
37204 fail:
37205 return NULL;
37206 }
37207
37208
37209 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37210 PyObject *resultobj = 0;
37211 wxWindow *arg1 = (wxWindow *) 0 ;
37212 wxValidator *result = 0 ;
37213 void *argp1 = 0 ;
37214 int res1 = 0 ;
37215 PyObject *swig_obj[1] ;
37216
37217 if (!args) SWIG_fail;
37218 swig_obj[0] = args;
37219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37220 if (!SWIG_IsOK(res1)) {
37221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37222 }
37223 arg1 = reinterpret_cast< wxWindow * >(argp1);
37224 {
37225 PyThreadState* __tstate = wxPyBeginAllowThreads();
37226 result = (wxValidator *)(arg1)->GetValidator();
37227 wxPyEndAllowThreads(__tstate);
37228 if (PyErr_Occurred()) SWIG_fail;
37229 }
37230 {
37231 resultobj = wxPyMake_wxObject(result, (bool)0);
37232 }
37233 return resultobj;
37234 fail:
37235 return NULL;
37236 }
37237
37238
37239 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37240 PyObject *resultobj = 0;
37241 wxWindow *arg1 = (wxWindow *) 0 ;
37242 bool result;
37243 void *argp1 = 0 ;
37244 int res1 = 0 ;
37245 PyObject *swig_obj[1] ;
37246
37247 if (!args) SWIG_fail;
37248 swig_obj[0] = args;
37249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37250 if (!SWIG_IsOK(res1)) {
37251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37252 }
37253 arg1 = reinterpret_cast< wxWindow * >(argp1);
37254 {
37255 PyThreadState* __tstate = wxPyBeginAllowThreads();
37256 result = (bool)(arg1)->Validate();
37257 wxPyEndAllowThreads(__tstate);
37258 if (PyErr_Occurred()) SWIG_fail;
37259 }
37260 {
37261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37262 }
37263 return resultobj;
37264 fail:
37265 return NULL;
37266 }
37267
37268
37269 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37270 PyObject *resultobj = 0;
37271 wxWindow *arg1 = (wxWindow *) 0 ;
37272 bool result;
37273 void *argp1 = 0 ;
37274 int res1 = 0 ;
37275 PyObject *swig_obj[1] ;
37276
37277 if (!args) SWIG_fail;
37278 swig_obj[0] = args;
37279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37280 if (!SWIG_IsOK(res1)) {
37281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37282 }
37283 arg1 = reinterpret_cast< wxWindow * >(argp1);
37284 {
37285 PyThreadState* __tstate = wxPyBeginAllowThreads();
37286 result = (bool)(arg1)->TransferDataToWindow();
37287 wxPyEndAllowThreads(__tstate);
37288 if (PyErr_Occurred()) SWIG_fail;
37289 }
37290 {
37291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37292 }
37293 return resultobj;
37294 fail:
37295 return NULL;
37296 }
37297
37298
37299 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37300 PyObject *resultobj = 0;
37301 wxWindow *arg1 = (wxWindow *) 0 ;
37302 bool result;
37303 void *argp1 = 0 ;
37304 int res1 = 0 ;
37305 PyObject *swig_obj[1] ;
37306
37307 if (!args) SWIG_fail;
37308 swig_obj[0] = args;
37309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37310 if (!SWIG_IsOK(res1)) {
37311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37312 }
37313 arg1 = reinterpret_cast< wxWindow * >(argp1);
37314 {
37315 PyThreadState* __tstate = wxPyBeginAllowThreads();
37316 result = (bool)(arg1)->TransferDataFromWindow();
37317 wxPyEndAllowThreads(__tstate);
37318 if (PyErr_Occurred()) SWIG_fail;
37319 }
37320 {
37321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37322 }
37323 return resultobj;
37324 fail:
37325 return NULL;
37326 }
37327
37328
37329 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37330 PyObject *resultobj = 0;
37331 wxWindow *arg1 = (wxWindow *) 0 ;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 PyObject *swig_obj[1] ;
37335
37336 if (!args) SWIG_fail;
37337 swig_obj[0] = args;
37338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37339 if (!SWIG_IsOK(res1)) {
37340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37341 }
37342 arg1 = reinterpret_cast< wxWindow * >(argp1);
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 (arg1)->InitDialog();
37346 wxPyEndAllowThreads(__tstate);
37347 if (PyErr_Occurred()) SWIG_fail;
37348 }
37349 resultobj = SWIG_Py_Void();
37350 return resultobj;
37351 fail:
37352 return NULL;
37353 }
37354
37355
37356 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37357 PyObject *resultobj = 0;
37358 wxWindow *arg1 = (wxWindow *) 0 ;
37359 wxAcceleratorTable *arg2 = 0 ;
37360 void *argp1 = 0 ;
37361 int res1 = 0 ;
37362 void *argp2 = 0 ;
37363 int res2 = 0 ;
37364 PyObject * obj0 = 0 ;
37365 PyObject * obj1 = 0 ;
37366 char * kwnames[] = {
37367 (char *) "self",(char *) "accel", NULL
37368 };
37369
37370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37372 if (!SWIG_IsOK(res1)) {
37373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37374 }
37375 arg1 = reinterpret_cast< wxWindow * >(argp1);
37376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37377 if (!SWIG_IsOK(res2)) {
37378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37379 }
37380 if (!argp2) {
37381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37382 }
37383 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37384 {
37385 PyThreadState* __tstate = wxPyBeginAllowThreads();
37386 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37387 wxPyEndAllowThreads(__tstate);
37388 if (PyErr_Occurred()) SWIG_fail;
37389 }
37390 resultobj = SWIG_Py_Void();
37391 return resultobj;
37392 fail:
37393 return NULL;
37394 }
37395
37396
37397 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37398 PyObject *resultobj = 0;
37399 wxWindow *arg1 = (wxWindow *) 0 ;
37400 wxAcceleratorTable *result = 0 ;
37401 void *argp1 = 0 ;
37402 int res1 = 0 ;
37403 PyObject *swig_obj[1] ;
37404
37405 if (!args) SWIG_fail;
37406 swig_obj[0] = args;
37407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37408 if (!SWIG_IsOK(res1)) {
37409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37410 }
37411 arg1 = reinterpret_cast< wxWindow * >(argp1);
37412 {
37413 PyThreadState* __tstate = wxPyBeginAllowThreads();
37414 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37415 wxPyEndAllowThreads(__tstate);
37416 if (PyErr_Occurred()) SWIG_fail;
37417 }
37418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37419 return resultobj;
37420 fail:
37421 return NULL;
37422 }
37423
37424
37425 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37426 PyObject *resultobj = 0;
37427 wxWindow *arg1 = (wxWindow *) 0 ;
37428 int arg2 ;
37429 int arg3 ;
37430 int arg4 ;
37431 bool result;
37432 void *argp1 = 0 ;
37433 int res1 = 0 ;
37434 int val2 ;
37435 int ecode2 = 0 ;
37436 int val3 ;
37437 int ecode3 = 0 ;
37438 int val4 ;
37439 int ecode4 = 0 ;
37440 PyObject * obj0 = 0 ;
37441 PyObject * obj1 = 0 ;
37442 PyObject * obj2 = 0 ;
37443 PyObject * obj3 = 0 ;
37444 char * kwnames[] = {
37445 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37446 };
37447
37448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37450 if (!SWIG_IsOK(res1)) {
37451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37452 }
37453 arg1 = reinterpret_cast< wxWindow * >(argp1);
37454 ecode2 = SWIG_AsVal_int(obj1, &val2);
37455 if (!SWIG_IsOK(ecode2)) {
37456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37457 }
37458 arg2 = static_cast< int >(val2);
37459 ecode3 = SWIG_AsVal_int(obj2, &val3);
37460 if (!SWIG_IsOK(ecode3)) {
37461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37462 }
37463 arg3 = static_cast< int >(val3);
37464 ecode4 = SWIG_AsVal_int(obj3, &val4);
37465 if (!SWIG_IsOK(ecode4)) {
37466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37467 }
37468 arg4 = static_cast< int >(val4);
37469 {
37470 PyThreadState* __tstate = wxPyBeginAllowThreads();
37471 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37472 wxPyEndAllowThreads(__tstate);
37473 if (PyErr_Occurred()) SWIG_fail;
37474 }
37475 {
37476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37477 }
37478 return resultobj;
37479 fail:
37480 return NULL;
37481 }
37482
37483
37484 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37485 PyObject *resultobj = 0;
37486 wxWindow *arg1 = (wxWindow *) 0 ;
37487 int arg2 ;
37488 bool result;
37489 void *argp1 = 0 ;
37490 int res1 = 0 ;
37491 int val2 ;
37492 int ecode2 = 0 ;
37493 PyObject * obj0 = 0 ;
37494 PyObject * obj1 = 0 ;
37495 char * kwnames[] = {
37496 (char *) "self",(char *) "hotkeyId", NULL
37497 };
37498
37499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37501 if (!SWIG_IsOK(res1)) {
37502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37503 }
37504 arg1 = reinterpret_cast< wxWindow * >(argp1);
37505 ecode2 = SWIG_AsVal_int(obj1, &val2);
37506 if (!SWIG_IsOK(ecode2)) {
37507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37508 }
37509 arg2 = static_cast< int >(val2);
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 {
37517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37518 }
37519 return resultobj;
37520 fail:
37521 return NULL;
37522 }
37523
37524
37525 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37526 PyObject *resultobj = 0;
37527 wxWindow *arg1 = (wxWindow *) 0 ;
37528 wxPoint *arg2 = 0 ;
37529 wxPoint result;
37530 void *argp1 = 0 ;
37531 int res1 = 0 ;
37532 wxPoint temp2 ;
37533 PyObject * obj0 = 0 ;
37534 PyObject * obj1 = 0 ;
37535 char * kwnames[] = {
37536 (char *) "self",(char *) "pt", NULL
37537 };
37538
37539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37541 if (!SWIG_IsOK(res1)) {
37542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37543 }
37544 arg1 = reinterpret_cast< wxWindow * >(argp1);
37545 {
37546 arg2 = &temp2;
37547 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37548 }
37549 {
37550 PyThreadState* __tstate = wxPyBeginAllowThreads();
37551 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37552 wxPyEndAllowThreads(__tstate);
37553 if (PyErr_Occurred()) SWIG_fail;
37554 }
37555 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37556 return resultobj;
37557 fail:
37558 return NULL;
37559 }
37560
37561
37562 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37563 PyObject *resultobj = 0;
37564 wxWindow *arg1 = (wxWindow *) 0 ;
37565 wxSize *arg2 = 0 ;
37566 wxSize result;
37567 void *argp1 = 0 ;
37568 int res1 = 0 ;
37569 wxSize temp2 ;
37570 PyObject * obj0 = 0 ;
37571 PyObject * obj1 = 0 ;
37572 char * kwnames[] = {
37573 (char *) "self",(char *) "sz", NULL
37574 };
37575
37576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37578 if (!SWIG_IsOK(res1)) {
37579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37580 }
37581 arg1 = reinterpret_cast< wxWindow * >(argp1);
37582 {
37583 arg2 = &temp2;
37584 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37585 }
37586 {
37587 PyThreadState* __tstate = wxPyBeginAllowThreads();
37588 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37589 wxPyEndAllowThreads(__tstate);
37590 if (PyErr_Occurred()) SWIG_fail;
37591 }
37592 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37593 return resultobj;
37594 fail:
37595 return NULL;
37596 }
37597
37598
37599 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37600 PyObject *resultobj = 0;
37601 wxWindow *arg1 = (wxWindow *) 0 ;
37602 wxPoint *arg2 = 0 ;
37603 wxPoint result;
37604 void *argp1 = 0 ;
37605 int res1 = 0 ;
37606 wxPoint temp2 ;
37607 PyObject * obj0 = 0 ;
37608 PyObject * obj1 = 0 ;
37609 char * kwnames[] = {
37610 (char *) "self",(char *) "pt", NULL
37611 };
37612
37613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37615 if (!SWIG_IsOK(res1)) {
37616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37617 }
37618 arg1 = reinterpret_cast< wxWindow * >(argp1);
37619 {
37620 arg2 = &temp2;
37621 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37622 }
37623 {
37624 PyThreadState* __tstate = wxPyBeginAllowThreads();
37625 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37626 wxPyEndAllowThreads(__tstate);
37627 if (PyErr_Occurred()) SWIG_fail;
37628 }
37629 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37630 return resultobj;
37631 fail:
37632 return NULL;
37633 }
37634
37635
37636 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37637 PyObject *resultobj = 0;
37638 wxWindow *arg1 = (wxWindow *) 0 ;
37639 wxSize *arg2 = 0 ;
37640 wxSize result;
37641 void *argp1 = 0 ;
37642 int res1 = 0 ;
37643 wxSize temp2 ;
37644 PyObject * obj0 = 0 ;
37645 PyObject * obj1 = 0 ;
37646 char * kwnames[] = {
37647 (char *) "self",(char *) "sz", NULL
37648 };
37649
37650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37652 if (!SWIG_IsOK(res1)) {
37653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37654 }
37655 arg1 = reinterpret_cast< wxWindow * >(argp1);
37656 {
37657 arg2 = &temp2;
37658 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37659 }
37660 {
37661 PyThreadState* __tstate = wxPyBeginAllowThreads();
37662 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37663 wxPyEndAllowThreads(__tstate);
37664 if (PyErr_Occurred()) SWIG_fail;
37665 }
37666 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37667 return resultobj;
37668 fail:
37669 return NULL;
37670 }
37671
37672
37673 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37674 PyObject *resultobj = 0;
37675 wxWindow *arg1 = (wxWindow *) 0 ;
37676 wxPoint *arg2 = 0 ;
37677 wxPoint result;
37678 void *argp1 = 0 ;
37679 int res1 = 0 ;
37680 wxPoint temp2 ;
37681 PyObject * obj0 = 0 ;
37682 PyObject * obj1 = 0 ;
37683 char * kwnames[] = {
37684 (char *) "self",(char *) "pt", NULL
37685 };
37686
37687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37689 if (!SWIG_IsOK(res1)) {
37690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37691 }
37692 arg1 = reinterpret_cast< wxWindow * >(argp1);
37693 {
37694 arg2 = &temp2;
37695 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37696 }
37697 {
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37700 wxPyEndAllowThreads(__tstate);
37701 if (PyErr_Occurred()) SWIG_fail;
37702 }
37703 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37711 PyObject *resultobj = 0;
37712 wxWindow *arg1 = (wxWindow *) 0 ;
37713 wxSize *arg2 = 0 ;
37714 wxSize result;
37715 void *argp1 = 0 ;
37716 int res1 = 0 ;
37717 wxSize temp2 ;
37718 PyObject * obj0 = 0 ;
37719 PyObject * obj1 = 0 ;
37720 char * kwnames[] = {
37721 (char *) "self",(char *) "sz", NULL
37722 };
37723
37724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37726 if (!SWIG_IsOK(res1)) {
37727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37728 }
37729 arg1 = reinterpret_cast< wxWindow * >(argp1);
37730 {
37731 arg2 = &temp2;
37732 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37733 }
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37741 return resultobj;
37742 fail:
37743 return NULL;
37744 }
37745
37746
37747 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37748 PyObject *resultobj = 0;
37749 wxWindow *arg1 = (wxWindow *) 0 ;
37750 int arg2 ;
37751 int arg3 ;
37752 void *argp1 = 0 ;
37753 int res1 = 0 ;
37754 int val2 ;
37755 int ecode2 = 0 ;
37756 int val3 ;
37757 int ecode3 = 0 ;
37758 PyObject * obj0 = 0 ;
37759 PyObject * obj1 = 0 ;
37760 PyObject * obj2 = 0 ;
37761 char * kwnames[] = {
37762 (char *) "self",(char *) "x",(char *) "y", NULL
37763 };
37764
37765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37767 if (!SWIG_IsOK(res1)) {
37768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37769 }
37770 arg1 = reinterpret_cast< wxWindow * >(argp1);
37771 ecode2 = SWIG_AsVal_int(obj1, &val2);
37772 if (!SWIG_IsOK(ecode2)) {
37773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37774 }
37775 arg2 = static_cast< int >(val2);
37776 ecode3 = SWIG_AsVal_int(obj2, &val3);
37777 if (!SWIG_IsOK(ecode3)) {
37778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37779 }
37780 arg3 = static_cast< int >(val3);
37781 {
37782 PyThreadState* __tstate = wxPyBeginAllowThreads();
37783 (arg1)->WarpPointer(arg2,arg3);
37784 wxPyEndAllowThreads(__tstate);
37785 if (PyErr_Occurred()) SWIG_fail;
37786 }
37787 resultobj = SWIG_Py_Void();
37788 return resultobj;
37789 fail:
37790 return NULL;
37791 }
37792
37793
37794 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37795 PyObject *resultobj = 0;
37796 wxWindow *arg1 = (wxWindow *) 0 ;
37797 void *argp1 = 0 ;
37798 int res1 = 0 ;
37799 PyObject *swig_obj[1] ;
37800
37801 if (!args) SWIG_fail;
37802 swig_obj[0] = args;
37803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37804 if (!SWIG_IsOK(res1)) {
37805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37806 }
37807 arg1 = reinterpret_cast< wxWindow * >(argp1);
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 (arg1)->CaptureMouse();
37811 wxPyEndAllowThreads(__tstate);
37812 if (PyErr_Occurred()) SWIG_fail;
37813 }
37814 resultobj = SWIG_Py_Void();
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37822 PyObject *resultobj = 0;
37823 wxWindow *arg1 = (wxWindow *) 0 ;
37824 void *argp1 = 0 ;
37825 int res1 = 0 ;
37826 PyObject *swig_obj[1] ;
37827
37828 if (!args) SWIG_fail;
37829 swig_obj[0] = args;
37830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37831 if (!SWIG_IsOK(res1)) {
37832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37833 }
37834 arg1 = reinterpret_cast< wxWindow * >(argp1);
37835 {
37836 PyThreadState* __tstate = wxPyBeginAllowThreads();
37837 (arg1)->ReleaseMouse();
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 resultobj = SWIG_Py_Void();
37842 return resultobj;
37843 fail:
37844 return NULL;
37845 }
37846
37847
37848 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37849 PyObject *resultobj = 0;
37850 wxWindow *result = 0 ;
37851
37852 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37853 {
37854 if (!wxPyCheckForApp()) SWIG_fail;
37855 PyThreadState* __tstate = wxPyBeginAllowThreads();
37856 result = (wxWindow *)wxWindow::GetCapture();
37857 wxPyEndAllowThreads(__tstate);
37858 if (PyErr_Occurred()) SWIG_fail;
37859 }
37860 {
37861 resultobj = wxPyMake_wxObject(result, 0);
37862 }
37863 return resultobj;
37864 fail:
37865 return NULL;
37866 }
37867
37868
37869 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37870 PyObject *resultobj = 0;
37871 wxWindow *arg1 = (wxWindow *) 0 ;
37872 bool result;
37873 void *argp1 = 0 ;
37874 int res1 = 0 ;
37875 PyObject *swig_obj[1] ;
37876
37877 if (!args) SWIG_fail;
37878 swig_obj[0] = args;
37879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37880 if (!SWIG_IsOK(res1)) {
37881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37882 }
37883 arg1 = reinterpret_cast< wxWindow * >(argp1);
37884 {
37885 PyThreadState* __tstate = wxPyBeginAllowThreads();
37886 result = (bool)((wxWindow const *)arg1)->HasCapture();
37887 wxPyEndAllowThreads(__tstate);
37888 if (PyErr_Occurred()) SWIG_fail;
37889 }
37890 {
37891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37892 }
37893 return resultobj;
37894 fail:
37895 return NULL;
37896 }
37897
37898
37899 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37900 PyObject *resultobj = 0;
37901 wxWindow *arg1 = (wxWindow *) 0 ;
37902 bool arg2 = (bool) true ;
37903 wxRect *arg3 = (wxRect *) NULL ;
37904 void *argp1 = 0 ;
37905 int res1 = 0 ;
37906 bool val2 ;
37907 int ecode2 = 0 ;
37908 void *argp3 = 0 ;
37909 int res3 = 0 ;
37910 PyObject * obj0 = 0 ;
37911 PyObject * obj1 = 0 ;
37912 PyObject * obj2 = 0 ;
37913 char * kwnames[] = {
37914 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37915 };
37916
37917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37919 if (!SWIG_IsOK(res1)) {
37920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37921 }
37922 arg1 = reinterpret_cast< wxWindow * >(argp1);
37923 if (obj1) {
37924 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37925 if (!SWIG_IsOK(ecode2)) {
37926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37927 }
37928 arg2 = static_cast< bool >(val2);
37929 }
37930 if (obj2) {
37931 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37932 if (!SWIG_IsOK(res3)) {
37933 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37934 }
37935 arg3 = reinterpret_cast< wxRect * >(argp3);
37936 }
37937 {
37938 PyThreadState* __tstate = wxPyBeginAllowThreads();
37939 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37940 wxPyEndAllowThreads(__tstate);
37941 if (PyErr_Occurred()) SWIG_fail;
37942 }
37943 resultobj = SWIG_Py_Void();
37944 return resultobj;
37945 fail:
37946 return NULL;
37947 }
37948
37949
37950 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37951 PyObject *resultobj = 0;
37952 wxWindow *arg1 = (wxWindow *) 0 ;
37953 wxRect *arg2 = 0 ;
37954 bool arg3 = (bool) true ;
37955 void *argp1 = 0 ;
37956 int res1 = 0 ;
37957 wxRect temp2 ;
37958 bool val3 ;
37959 int ecode3 = 0 ;
37960 PyObject * obj0 = 0 ;
37961 PyObject * obj1 = 0 ;
37962 PyObject * obj2 = 0 ;
37963 char * kwnames[] = {
37964 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37965 };
37966
37967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37969 if (!SWIG_IsOK(res1)) {
37970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37971 }
37972 arg1 = reinterpret_cast< wxWindow * >(argp1);
37973 {
37974 arg2 = &temp2;
37975 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37976 }
37977 if (obj2) {
37978 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37979 if (!SWIG_IsOK(ecode3)) {
37980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37981 }
37982 arg3 = static_cast< bool >(val3);
37983 }
37984 {
37985 PyThreadState* __tstate = wxPyBeginAllowThreads();
37986 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 resultobj = SWIG_Py_Void();
37991 return resultobj;
37992 fail:
37993 return NULL;
37994 }
37995
37996
37997 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37998 PyObject *resultobj = 0;
37999 wxWindow *arg1 = (wxWindow *) 0 ;
38000 void *argp1 = 0 ;
38001 int res1 = 0 ;
38002 PyObject *swig_obj[1] ;
38003
38004 if (!args) SWIG_fail;
38005 swig_obj[0] = args;
38006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38007 if (!SWIG_IsOK(res1)) {
38008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38009 }
38010 arg1 = reinterpret_cast< wxWindow * >(argp1);
38011 {
38012 PyThreadState* __tstate = wxPyBeginAllowThreads();
38013 (arg1)->Update();
38014 wxPyEndAllowThreads(__tstate);
38015 if (PyErr_Occurred()) SWIG_fail;
38016 }
38017 resultobj = SWIG_Py_Void();
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38025 PyObject *resultobj = 0;
38026 wxWindow *arg1 = (wxWindow *) 0 ;
38027 void *argp1 = 0 ;
38028 int res1 = 0 ;
38029 PyObject *swig_obj[1] ;
38030
38031 if (!args) SWIG_fail;
38032 swig_obj[0] = args;
38033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38034 if (!SWIG_IsOK(res1)) {
38035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38036 }
38037 arg1 = reinterpret_cast< wxWindow * >(argp1);
38038 {
38039 PyThreadState* __tstate = wxPyBeginAllowThreads();
38040 (arg1)->ClearBackground();
38041 wxPyEndAllowThreads(__tstate);
38042 if (PyErr_Occurred()) SWIG_fail;
38043 }
38044 resultobj = SWIG_Py_Void();
38045 return resultobj;
38046 fail:
38047 return NULL;
38048 }
38049
38050
38051 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38052 PyObject *resultobj = 0;
38053 wxWindow *arg1 = (wxWindow *) 0 ;
38054 void *argp1 = 0 ;
38055 int res1 = 0 ;
38056 PyObject *swig_obj[1] ;
38057
38058 if (!args) SWIG_fail;
38059 swig_obj[0] = args;
38060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38063 }
38064 arg1 = reinterpret_cast< wxWindow * >(argp1);
38065 {
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 (arg1)->Freeze();
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_Py_Void();
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38079 PyObject *resultobj = 0;
38080 wxWindow *arg1 = (wxWindow *) 0 ;
38081 bool result;
38082 void *argp1 = 0 ;
38083 int res1 = 0 ;
38084 PyObject *swig_obj[1] ;
38085
38086 if (!args) SWIG_fail;
38087 swig_obj[0] = args;
38088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38089 if (!SWIG_IsOK(res1)) {
38090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38091 }
38092 arg1 = reinterpret_cast< wxWindow * >(argp1);
38093 {
38094 PyThreadState* __tstate = wxPyBeginAllowThreads();
38095 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 {
38100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38101 }
38102 return resultobj;
38103 fail:
38104 return NULL;
38105 }
38106
38107
38108 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38109 PyObject *resultobj = 0;
38110 wxWindow *arg1 = (wxWindow *) 0 ;
38111 void *argp1 = 0 ;
38112 int res1 = 0 ;
38113 PyObject *swig_obj[1] ;
38114
38115 if (!args) SWIG_fail;
38116 swig_obj[0] = args;
38117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38118 if (!SWIG_IsOK(res1)) {
38119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38120 }
38121 arg1 = reinterpret_cast< wxWindow * >(argp1);
38122 {
38123 PyThreadState* __tstate = wxPyBeginAllowThreads();
38124 (arg1)->Thaw();
38125 wxPyEndAllowThreads(__tstate);
38126 if (PyErr_Occurred()) SWIG_fail;
38127 }
38128 resultobj = SWIG_Py_Void();
38129 return resultobj;
38130 fail:
38131 return NULL;
38132 }
38133
38134
38135 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38136 PyObject *resultobj = 0;
38137 wxWindow *arg1 = (wxWindow *) 0 ;
38138 wxDC *arg2 = 0 ;
38139 void *argp1 = 0 ;
38140 int res1 = 0 ;
38141 void *argp2 = 0 ;
38142 int res2 = 0 ;
38143 PyObject * obj0 = 0 ;
38144 PyObject * obj1 = 0 ;
38145 char * kwnames[] = {
38146 (char *) "self",(char *) "dc", NULL
38147 };
38148
38149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38151 if (!SWIG_IsOK(res1)) {
38152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38153 }
38154 arg1 = reinterpret_cast< wxWindow * >(argp1);
38155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38156 if (!SWIG_IsOK(res2)) {
38157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38158 }
38159 if (!argp2) {
38160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38161 }
38162 arg2 = reinterpret_cast< wxDC * >(argp2);
38163 {
38164 PyThreadState* __tstate = wxPyBeginAllowThreads();
38165 (arg1)->PrepareDC(*arg2);
38166 wxPyEndAllowThreads(__tstate);
38167 if (PyErr_Occurred()) SWIG_fail;
38168 }
38169 resultobj = SWIG_Py_Void();
38170 return resultobj;
38171 fail:
38172 return NULL;
38173 }
38174
38175
38176 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38177 PyObject *resultobj = 0;
38178 wxWindow *arg1 = (wxWindow *) 0 ;
38179 bool result;
38180 void *argp1 = 0 ;
38181 int res1 = 0 ;
38182 PyObject *swig_obj[1] ;
38183
38184 if (!args) SWIG_fail;
38185 swig_obj[0] = args;
38186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38187 if (!SWIG_IsOK(res1)) {
38188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38189 }
38190 arg1 = reinterpret_cast< wxWindow * >(argp1);
38191 {
38192 PyThreadState* __tstate = wxPyBeginAllowThreads();
38193 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38194 wxPyEndAllowThreads(__tstate);
38195 if (PyErr_Occurred()) SWIG_fail;
38196 }
38197 {
38198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38199 }
38200 return resultobj;
38201 fail:
38202 return NULL;
38203 }
38204
38205
38206 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38207 PyObject *resultobj = 0;
38208 wxWindow *arg1 = (wxWindow *) 0 ;
38209 wxRegion *result = 0 ;
38210 void *argp1 = 0 ;
38211 int res1 = 0 ;
38212 PyObject *swig_obj[1] ;
38213
38214 if (!args) SWIG_fail;
38215 swig_obj[0] = args;
38216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38217 if (!SWIG_IsOK(res1)) {
38218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38219 }
38220 arg1 = reinterpret_cast< wxWindow * >(argp1);
38221 {
38222 PyThreadState* __tstate = wxPyBeginAllowThreads();
38223 {
38224 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38225 result = (wxRegion *) &_result_ref;
38226 }
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38231 return resultobj;
38232 fail:
38233 return NULL;
38234 }
38235
38236
38237 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38238 PyObject *resultobj = 0;
38239 wxWindow *arg1 = (wxWindow *) 0 ;
38240 wxRect result;
38241 void *argp1 = 0 ;
38242 int res1 = 0 ;
38243 PyObject *swig_obj[1] ;
38244
38245 if (!args) SWIG_fail;
38246 swig_obj[0] = args;
38247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38248 if (!SWIG_IsOK(res1)) {
38249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38250 }
38251 arg1 = reinterpret_cast< wxWindow * >(argp1);
38252 {
38253 PyThreadState* __tstate = wxPyBeginAllowThreads();
38254 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38255 wxPyEndAllowThreads(__tstate);
38256 if (PyErr_Occurred()) SWIG_fail;
38257 }
38258 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38259 return resultobj;
38260 fail:
38261 return NULL;
38262 }
38263
38264
38265 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38266 PyObject *resultobj = 0;
38267 wxWindow *arg1 = (wxWindow *) 0 ;
38268 int arg2 ;
38269 int arg3 ;
38270 int arg4 = (int) 1 ;
38271 int arg5 = (int) 1 ;
38272 bool result;
38273 void *argp1 = 0 ;
38274 int res1 = 0 ;
38275 int val2 ;
38276 int ecode2 = 0 ;
38277 int val3 ;
38278 int ecode3 = 0 ;
38279 int val4 ;
38280 int ecode4 = 0 ;
38281 int val5 ;
38282 int ecode5 = 0 ;
38283 PyObject * obj0 = 0 ;
38284 PyObject * obj1 = 0 ;
38285 PyObject * obj2 = 0 ;
38286 PyObject * obj3 = 0 ;
38287 PyObject * obj4 = 0 ;
38288 char * kwnames[] = {
38289 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38290 };
38291
38292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38294 if (!SWIG_IsOK(res1)) {
38295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38296 }
38297 arg1 = reinterpret_cast< wxWindow * >(argp1);
38298 ecode2 = SWIG_AsVal_int(obj1, &val2);
38299 if (!SWIG_IsOK(ecode2)) {
38300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38301 }
38302 arg2 = static_cast< int >(val2);
38303 ecode3 = SWIG_AsVal_int(obj2, &val3);
38304 if (!SWIG_IsOK(ecode3)) {
38305 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38306 }
38307 arg3 = static_cast< int >(val3);
38308 if (obj3) {
38309 ecode4 = SWIG_AsVal_int(obj3, &val4);
38310 if (!SWIG_IsOK(ecode4)) {
38311 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38312 }
38313 arg4 = static_cast< int >(val4);
38314 }
38315 if (obj4) {
38316 ecode5 = SWIG_AsVal_int(obj4, &val5);
38317 if (!SWIG_IsOK(ecode5)) {
38318 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38319 }
38320 arg5 = static_cast< int >(val5);
38321 }
38322 {
38323 PyThreadState* __tstate = wxPyBeginAllowThreads();
38324 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38325 wxPyEndAllowThreads(__tstate);
38326 if (PyErr_Occurred()) SWIG_fail;
38327 }
38328 {
38329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38330 }
38331 return resultobj;
38332 fail:
38333 return NULL;
38334 }
38335
38336
38337 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38338 PyObject *resultobj = 0;
38339 wxWindow *arg1 = (wxWindow *) 0 ;
38340 wxPoint *arg2 = 0 ;
38341 bool result;
38342 void *argp1 = 0 ;
38343 int res1 = 0 ;
38344 wxPoint temp2 ;
38345 PyObject * obj0 = 0 ;
38346 PyObject * obj1 = 0 ;
38347 char * kwnames[] = {
38348 (char *) "self",(char *) "pt", NULL
38349 };
38350
38351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38353 if (!SWIG_IsOK(res1)) {
38354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38355 }
38356 arg1 = reinterpret_cast< wxWindow * >(argp1);
38357 {
38358 arg2 = &temp2;
38359 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38360 }
38361 {
38362 PyThreadState* __tstate = wxPyBeginAllowThreads();
38363 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38364 wxPyEndAllowThreads(__tstate);
38365 if (PyErr_Occurred()) SWIG_fail;
38366 }
38367 {
38368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38369 }
38370 return resultobj;
38371 fail:
38372 return NULL;
38373 }
38374
38375
38376 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38377 PyObject *resultobj = 0;
38378 wxWindow *arg1 = (wxWindow *) 0 ;
38379 wxRect *arg2 = 0 ;
38380 bool result;
38381 void *argp1 = 0 ;
38382 int res1 = 0 ;
38383 wxRect temp2 ;
38384 PyObject * obj0 = 0 ;
38385 PyObject * obj1 = 0 ;
38386 char * kwnames[] = {
38387 (char *) "self",(char *) "rect", NULL
38388 };
38389
38390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38392 if (!SWIG_IsOK(res1)) {
38393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38394 }
38395 arg1 = reinterpret_cast< wxWindow * >(argp1);
38396 {
38397 arg2 = &temp2;
38398 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38399 }
38400 {
38401 PyThreadState* __tstate = wxPyBeginAllowThreads();
38402 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38403 wxPyEndAllowThreads(__tstate);
38404 if (PyErr_Occurred()) SWIG_fail;
38405 }
38406 {
38407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38408 }
38409 return resultobj;
38410 fail:
38411 return NULL;
38412 }
38413
38414
38415 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38416 PyObject *resultobj = 0;
38417 wxWindow *arg1 = (wxWindow *) 0 ;
38418 SwigValueWrapper<wxVisualAttributes > result;
38419 void *argp1 = 0 ;
38420 int res1 = 0 ;
38421 PyObject *swig_obj[1] ;
38422
38423 if (!args) SWIG_fail;
38424 swig_obj[0] = args;
38425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38426 if (!SWIG_IsOK(res1)) {
38427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38428 }
38429 arg1 = reinterpret_cast< wxWindow * >(argp1);
38430 {
38431 PyThreadState* __tstate = wxPyBeginAllowThreads();
38432 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38433 wxPyEndAllowThreads(__tstate);
38434 if (PyErr_Occurred()) SWIG_fail;
38435 }
38436 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38437 return resultobj;
38438 fail:
38439 return NULL;
38440 }
38441
38442
38443 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38444 PyObject *resultobj = 0;
38445 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38446 SwigValueWrapper<wxVisualAttributes > result;
38447 int val1 ;
38448 int ecode1 = 0 ;
38449 PyObject * obj0 = 0 ;
38450 char * kwnames[] = {
38451 (char *) "variant", NULL
38452 };
38453
38454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38455 if (obj0) {
38456 ecode1 = SWIG_AsVal_int(obj0, &val1);
38457 if (!SWIG_IsOK(ecode1)) {
38458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38459 }
38460 arg1 = static_cast< wxWindowVariant >(val1);
38461 }
38462 {
38463 if (!wxPyCheckForApp()) SWIG_fail;
38464 PyThreadState* __tstate = wxPyBeginAllowThreads();
38465 result = wxWindow::GetClassDefaultAttributes(arg1);
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38470 return resultobj;
38471 fail:
38472 return NULL;
38473 }
38474
38475
38476 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38477 PyObject *resultobj = 0;
38478 wxWindow *arg1 = (wxWindow *) 0 ;
38479 wxColour *arg2 = 0 ;
38480 bool result;
38481 void *argp1 = 0 ;
38482 int res1 = 0 ;
38483 wxColour temp2 ;
38484 PyObject * obj0 = 0 ;
38485 PyObject * obj1 = 0 ;
38486 char * kwnames[] = {
38487 (char *) "self",(char *) "colour", NULL
38488 };
38489
38490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38492 if (!SWIG_IsOK(res1)) {
38493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38494 }
38495 arg1 = reinterpret_cast< wxWindow * >(argp1);
38496 {
38497 arg2 = &temp2;
38498 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38499 }
38500 {
38501 PyThreadState* __tstate = wxPyBeginAllowThreads();
38502 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38503 wxPyEndAllowThreads(__tstate);
38504 if (PyErr_Occurred()) SWIG_fail;
38505 }
38506 {
38507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38508 }
38509 return resultobj;
38510 fail:
38511 return NULL;
38512 }
38513
38514
38515 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38516 PyObject *resultobj = 0;
38517 wxWindow *arg1 = (wxWindow *) 0 ;
38518 wxColour *arg2 = 0 ;
38519 void *argp1 = 0 ;
38520 int res1 = 0 ;
38521 wxColour temp2 ;
38522 PyObject * obj0 = 0 ;
38523 PyObject * obj1 = 0 ;
38524 char * kwnames[] = {
38525 (char *) "self",(char *) "colour", NULL
38526 };
38527
38528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38530 if (!SWIG_IsOK(res1)) {
38531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38532 }
38533 arg1 = reinterpret_cast< wxWindow * >(argp1);
38534 {
38535 arg2 = &temp2;
38536 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38537 }
38538 {
38539 PyThreadState* __tstate = wxPyBeginAllowThreads();
38540 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 resultobj = SWIG_Py_Void();
38545 return resultobj;
38546 fail:
38547 return NULL;
38548 }
38549
38550
38551 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38552 PyObject *resultobj = 0;
38553 wxWindow *arg1 = (wxWindow *) 0 ;
38554 wxColour *arg2 = 0 ;
38555 bool result;
38556 void *argp1 = 0 ;
38557 int res1 = 0 ;
38558 wxColour temp2 ;
38559 PyObject * obj0 = 0 ;
38560 PyObject * obj1 = 0 ;
38561 char * kwnames[] = {
38562 (char *) "self",(char *) "colour", NULL
38563 };
38564
38565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38567 if (!SWIG_IsOK(res1)) {
38568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38569 }
38570 arg1 = reinterpret_cast< wxWindow * >(argp1);
38571 {
38572 arg2 = &temp2;
38573 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38574 }
38575 {
38576 PyThreadState* __tstate = wxPyBeginAllowThreads();
38577 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38578 wxPyEndAllowThreads(__tstate);
38579 if (PyErr_Occurred()) SWIG_fail;
38580 }
38581 {
38582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38583 }
38584 return resultobj;
38585 fail:
38586 return NULL;
38587 }
38588
38589
38590 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38591 PyObject *resultobj = 0;
38592 wxWindow *arg1 = (wxWindow *) 0 ;
38593 wxColour *arg2 = 0 ;
38594 void *argp1 = 0 ;
38595 int res1 = 0 ;
38596 wxColour temp2 ;
38597 PyObject * obj0 = 0 ;
38598 PyObject * obj1 = 0 ;
38599 char * kwnames[] = {
38600 (char *) "self",(char *) "colour", NULL
38601 };
38602
38603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38605 if (!SWIG_IsOK(res1)) {
38606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38607 }
38608 arg1 = reinterpret_cast< wxWindow * >(argp1);
38609 {
38610 arg2 = &temp2;
38611 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38612 }
38613 {
38614 PyThreadState* __tstate = wxPyBeginAllowThreads();
38615 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38616 wxPyEndAllowThreads(__tstate);
38617 if (PyErr_Occurred()) SWIG_fail;
38618 }
38619 resultobj = SWIG_Py_Void();
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38627 PyObject *resultobj = 0;
38628 wxWindow *arg1 = (wxWindow *) 0 ;
38629 wxColour result;
38630 void *argp1 = 0 ;
38631 int res1 = 0 ;
38632 PyObject *swig_obj[1] ;
38633
38634 if (!args) SWIG_fail;
38635 swig_obj[0] = args;
38636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38637 if (!SWIG_IsOK(res1)) {
38638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38639 }
38640 arg1 = reinterpret_cast< wxWindow * >(argp1);
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38644 wxPyEndAllowThreads(__tstate);
38645 if (PyErr_Occurred()) SWIG_fail;
38646 }
38647 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38648 return resultobj;
38649 fail:
38650 return NULL;
38651 }
38652
38653
38654 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38655 PyObject *resultobj = 0;
38656 wxWindow *arg1 = (wxWindow *) 0 ;
38657 wxColour result;
38658 void *argp1 = 0 ;
38659 int res1 = 0 ;
38660 PyObject *swig_obj[1] ;
38661
38662 if (!args) SWIG_fail;
38663 swig_obj[0] = args;
38664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38665 if (!SWIG_IsOK(res1)) {
38666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38667 }
38668 arg1 = reinterpret_cast< wxWindow * >(argp1);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 result = ((wxWindow const *)arg1)->GetForegroundColour();
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38676 return resultobj;
38677 fail:
38678 return NULL;
38679 }
38680
38681
38682 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38683 PyObject *resultobj = 0;
38684 wxWindow *arg1 = (wxWindow *) 0 ;
38685 bool result;
38686 void *argp1 = 0 ;
38687 int res1 = 0 ;
38688 PyObject *swig_obj[1] ;
38689
38690 if (!args) SWIG_fail;
38691 swig_obj[0] = args;
38692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38693 if (!SWIG_IsOK(res1)) {
38694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38695 }
38696 arg1 = reinterpret_cast< wxWindow * >(argp1);
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 {
38704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38705 }
38706 return resultobj;
38707 fail:
38708 return NULL;
38709 }
38710
38711
38712 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38713 PyObject *resultobj = 0;
38714 wxWindow *arg1 = (wxWindow *) 0 ;
38715 bool result;
38716 void *argp1 = 0 ;
38717 int res1 = 0 ;
38718 PyObject *swig_obj[1] ;
38719
38720 if (!args) SWIG_fail;
38721 swig_obj[0] = args;
38722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38723 if (!SWIG_IsOK(res1)) {
38724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38725 }
38726 arg1 = reinterpret_cast< wxWindow * >(argp1);
38727 {
38728 PyThreadState* __tstate = wxPyBeginAllowThreads();
38729 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38730 wxPyEndAllowThreads(__tstate);
38731 if (PyErr_Occurred()) SWIG_fail;
38732 }
38733 {
38734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38735 }
38736 return resultobj;
38737 fail:
38738 return NULL;
38739 }
38740
38741
38742 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38743 PyObject *resultobj = 0;
38744 wxWindow *arg1 = (wxWindow *) 0 ;
38745 wxBackgroundStyle arg2 ;
38746 bool result;
38747 void *argp1 = 0 ;
38748 int res1 = 0 ;
38749 int val2 ;
38750 int ecode2 = 0 ;
38751 PyObject * obj0 = 0 ;
38752 PyObject * obj1 = 0 ;
38753 char * kwnames[] = {
38754 (char *) "self",(char *) "style", NULL
38755 };
38756
38757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38759 if (!SWIG_IsOK(res1)) {
38760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38761 }
38762 arg1 = reinterpret_cast< wxWindow * >(argp1);
38763 ecode2 = SWIG_AsVal_int(obj1, &val2);
38764 if (!SWIG_IsOK(ecode2)) {
38765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38766 }
38767 arg2 = static_cast< wxBackgroundStyle >(val2);
38768 {
38769 PyThreadState* __tstate = wxPyBeginAllowThreads();
38770 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38771 wxPyEndAllowThreads(__tstate);
38772 if (PyErr_Occurred()) SWIG_fail;
38773 }
38774 {
38775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38776 }
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38784 PyObject *resultobj = 0;
38785 wxWindow *arg1 = (wxWindow *) 0 ;
38786 wxBackgroundStyle result;
38787 void *argp1 = 0 ;
38788 int res1 = 0 ;
38789 PyObject *swig_obj[1] ;
38790
38791 if (!args) SWIG_fail;
38792 swig_obj[0] = args;
38793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38794 if (!SWIG_IsOK(res1)) {
38795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38796 }
38797 arg1 = reinterpret_cast< wxWindow * >(argp1);
38798 {
38799 PyThreadState* __tstate = wxPyBeginAllowThreads();
38800 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38801 wxPyEndAllowThreads(__tstate);
38802 if (PyErr_Occurred()) SWIG_fail;
38803 }
38804 resultobj = SWIG_From_int(static_cast< int >(result));
38805 return resultobj;
38806 fail:
38807 return NULL;
38808 }
38809
38810
38811 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38812 PyObject *resultobj = 0;
38813 wxWindow *arg1 = (wxWindow *) 0 ;
38814 bool result;
38815 void *argp1 = 0 ;
38816 int res1 = 0 ;
38817 PyObject *swig_obj[1] ;
38818
38819 if (!args) SWIG_fail;
38820 swig_obj[0] = args;
38821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38822 if (!SWIG_IsOK(res1)) {
38823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38824 }
38825 arg1 = reinterpret_cast< wxWindow * >(argp1);
38826 {
38827 PyThreadState* __tstate = wxPyBeginAllowThreads();
38828 result = (bool)(arg1)->HasTransparentBackground();
38829 wxPyEndAllowThreads(__tstate);
38830 if (PyErr_Occurred()) SWIG_fail;
38831 }
38832 {
38833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38834 }
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38842 PyObject *resultobj = 0;
38843 wxWindow *arg1 = (wxWindow *) 0 ;
38844 wxCursor *arg2 = 0 ;
38845 bool result;
38846 void *argp1 = 0 ;
38847 int res1 = 0 ;
38848 void *argp2 = 0 ;
38849 int res2 = 0 ;
38850 PyObject * obj0 = 0 ;
38851 PyObject * obj1 = 0 ;
38852 char * kwnames[] = {
38853 (char *) "self",(char *) "cursor", NULL
38854 };
38855
38856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38858 if (!SWIG_IsOK(res1)) {
38859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38860 }
38861 arg1 = reinterpret_cast< wxWindow * >(argp1);
38862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38863 if (!SWIG_IsOK(res2)) {
38864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38865 }
38866 if (!argp2) {
38867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38868 }
38869 arg2 = reinterpret_cast< wxCursor * >(argp2);
38870 {
38871 PyThreadState* __tstate = wxPyBeginAllowThreads();
38872 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38873 wxPyEndAllowThreads(__tstate);
38874 if (PyErr_Occurred()) SWIG_fail;
38875 }
38876 {
38877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38878 }
38879 return resultobj;
38880 fail:
38881 return NULL;
38882 }
38883
38884
38885 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38886 PyObject *resultobj = 0;
38887 wxWindow *arg1 = (wxWindow *) 0 ;
38888 wxCursor result;
38889 void *argp1 = 0 ;
38890 int res1 = 0 ;
38891 PyObject *swig_obj[1] ;
38892
38893 if (!args) SWIG_fail;
38894 swig_obj[0] = args;
38895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38896 if (!SWIG_IsOK(res1)) {
38897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38898 }
38899 arg1 = reinterpret_cast< wxWindow * >(argp1);
38900 {
38901 PyThreadState* __tstate = wxPyBeginAllowThreads();
38902 result = (arg1)->GetCursor();
38903 wxPyEndAllowThreads(__tstate);
38904 if (PyErr_Occurred()) SWIG_fail;
38905 }
38906 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38907 return resultobj;
38908 fail:
38909 return NULL;
38910 }
38911
38912
38913 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38914 PyObject *resultobj = 0;
38915 wxWindow *arg1 = (wxWindow *) 0 ;
38916 wxFont *arg2 = 0 ;
38917 bool result;
38918 void *argp1 = 0 ;
38919 int res1 = 0 ;
38920 void *argp2 = 0 ;
38921 int res2 = 0 ;
38922 PyObject * obj0 = 0 ;
38923 PyObject * obj1 = 0 ;
38924 char * kwnames[] = {
38925 (char *) "self",(char *) "font", NULL
38926 };
38927
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38932 }
38933 arg1 = reinterpret_cast< wxWindow * >(argp1);
38934 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38935 if (!SWIG_IsOK(res2)) {
38936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38937 }
38938 if (!argp2) {
38939 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38940 }
38941 arg2 = reinterpret_cast< wxFont * >(argp2);
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38945 wxPyEndAllowThreads(__tstate);
38946 if (PyErr_Occurred()) SWIG_fail;
38947 }
38948 {
38949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38950 }
38951 return resultobj;
38952 fail:
38953 return NULL;
38954 }
38955
38956
38957 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38958 PyObject *resultobj = 0;
38959 wxWindow *arg1 = (wxWindow *) 0 ;
38960 wxFont *arg2 = 0 ;
38961 void *argp1 = 0 ;
38962 int res1 = 0 ;
38963 void *argp2 = 0 ;
38964 int res2 = 0 ;
38965 PyObject * obj0 = 0 ;
38966 PyObject * obj1 = 0 ;
38967 char * kwnames[] = {
38968 (char *) "self",(char *) "font", NULL
38969 };
38970
38971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38973 if (!SWIG_IsOK(res1)) {
38974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38975 }
38976 arg1 = reinterpret_cast< wxWindow * >(argp1);
38977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38978 if (!SWIG_IsOK(res2)) {
38979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38980 }
38981 if (!argp2) {
38982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38983 }
38984 arg2 = reinterpret_cast< wxFont * >(argp2);
38985 {
38986 PyThreadState* __tstate = wxPyBeginAllowThreads();
38987 (arg1)->SetOwnFont((wxFont const &)*arg2);
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 resultobj = SWIG_Py_Void();
38992 return resultobj;
38993 fail:
38994 return NULL;
38995 }
38996
38997
38998 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38999 PyObject *resultobj = 0;
39000 wxWindow *arg1 = (wxWindow *) 0 ;
39001 wxFont result;
39002 void *argp1 = 0 ;
39003 int res1 = 0 ;
39004 PyObject *swig_obj[1] ;
39005
39006 if (!args) SWIG_fail;
39007 swig_obj[0] = args;
39008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39009 if (!SWIG_IsOK(res1)) {
39010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39011 }
39012 arg1 = reinterpret_cast< wxWindow * >(argp1);
39013 {
39014 PyThreadState* __tstate = wxPyBeginAllowThreads();
39015 result = (arg1)->GetFont();
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39020 return resultobj;
39021 fail:
39022 return NULL;
39023 }
39024
39025
39026 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39027 PyObject *resultobj = 0;
39028 wxWindow *arg1 = (wxWindow *) 0 ;
39029 wxCaret *arg2 = (wxCaret *) 0 ;
39030 void *argp1 = 0 ;
39031 int res1 = 0 ;
39032 int res2 = 0 ;
39033 PyObject * obj0 = 0 ;
39034 PyObject * obj1 = 0 ;
39035 char * kwnames[] = {
39036 (char *) "self",(char *) "caret", NULL
39037 };
39038
39039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39041 if (!SWIG_IsOK(res1)) {
39042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39043 }
39044 arg1 = reinterpret_cast< wxWindow * >(argp1);
39045 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39046 if (!SWIG_IsOK(res2)) {
39047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39048 }
39049 {
39050 PyThreadState* __tstate = wxPyBeginAllowThreads();
39051 (arg1)->SetCaret(arg2);
39052 wxPyEndAllowThreads(__tstate);
39053 if (PyErr_Occurred()) SWIG_fail;
39054 }
39055 resultobj = SWIG_Py_Void();
39056 return resultobj;
39057 fail:
39058 return NULL;
39059 }
39060
39061
39062 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39063 PyObject *resultobj = 0;
39064 wxWindow *arg1 = (wxWindow *) 0 ;
39065 wxCaret *result = 0 ;
39066 void *argp1 = 0 ;
39067 int res1 = 0 ;
39068 PyObject *swig_obj[1] ;
39069
39070 if (!args) SWIG_fail;
39071 swig_obj[0] = args;
39072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39073 if (!SWIG_IsOK(res1)) {
39074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39075 }
39076 arg1 = reinterpret_cast< wxWindow * >(argp1);
39077 {
39078 PyThreadState* __tstate = wxPyBeginAllowThreads();
39079 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39080 wxPyEndAllowThreads(__tstate);
39081 if (PyErr_Occurred()) SWIG_fail;
39082 }
39083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39084 return resultobj;
39085 fail:
39086 return NULL;
39087 }
39088
39089
39090 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39091 PyObject *resultobj = 0;
39092 wxWindow *arg1 = (wxWindow *) 0 ;
39093 int result;
39094 void *argp1 = 0 ;
39095 int res1 = 0 ;
39096 PyObject *swig_obj[1] ;
39097
39098 if (!args) SWIG_fail;
39099 swig_obj[0] = args;
39100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39101 if (!SWIG_IsOK(res1)) {
39102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39103 }
39104 arg1 = reinterpret_cast< wxWindow * >(argp1);
39105 {
39106 PyThreadState* __tstate = wxPyBeginAllowThreads();
39107 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39108 wxPyEndAllowThreads(__tstate);
39109 if (PyErr_Occurred()) SWIG_fail;
39110 }
39111 resultobj = SWIG_From_int(static_cast< int >(result));
39112 return resultobj;
39113 fail:
39114 return NULL;
39115 }
39116
39117
39118 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39119 PyObject *resultobj = 0;
39120 wxWindow *arg1 = (wxWindow *) 0 ;
39121 int result;
39122 void *argp1 = 0 ;
39123 int res1 = 0 ;
39124 PyObject *swig_obj[1] ;
39125
39126 if (!args) SWIG_fail;
39127 swig_obj[0] = args;
39128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39129 if (!SWIG_IsOK(res1)) {
39130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39131 }
39132 arg1 = reinterpret_cast< wxWindow * >(argp1);
39133 {
39134 PyThreadState* __tstate = wxPyBeginAllowThreads();
39135 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39136 wxPyEndAllowThreads(__tstate);
39137 if (PyErr_Occurred()) SWIG_fail;
39138 }
39139 resultobj = SWIG_From_int(static_cast< int >(result));
39140 return resultobj;
39141 fail:
39142 return NULL;
39143 }
39144
39145
39146 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39147 PyObject *resultobj = 0;
39148 wxWindow *arg1 = (wxWindow *) 0 ;
39149 wxString *arg2 = 0 ;
39150 int *arg3 = (int *) 0 ;
39151 int *arg4 = (int *) 0 ;
39152 void *argp1 = 0 ;
39153 int res1 = 0 ;
39154 bool temp2 = false ;
39155 int temp3 ;
39156 int res3 = SWIG_TMPOBJ ;
39157 int temp4 ;
39158 int res4 = SWIG_TMPOBJ ;
39159 PyObject * obj0 = 0 ;
39160 PyObject * obj1 = 0 ;
39161 char * kwnames[] = {
39162 (char *) "self",(char *) "string", NULL
39163 };
39164
39165 arg3 = &temp3;
39166 arg4 = &temp4;
39167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39169 if (!SWIG_IsOK(res1)) {
39170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39171 }
39172 arg1 = reinterpret_cast< wxWindow * >(argp1);
39173 {
39174 arg2 = wxString_in_helper(obj1);
39175 if (arg2 == NULL) SWIG_fail;
39176 temp2 = true;
39177 }
39178 {
39179 PyThreadState* __tstate = wxPyBeginAllowThreads();
39180 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39181 wxPyEndAllowThreads(__tstate);
39182 if (PyErr_Occurred()) SWIG_fail;
39183 }
39184 resultobj = SWIG_Py_Void();
39185 if (SWIG_IsTmpObj(res3)) {
39186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39187 } else {
39188 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39190 }
39191 if (SWIG_IsTmpObj(res4)) {
39192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39193 } else {
39194 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39196 }
39197 {
39198 if (temp2)
39199 delete arg2;
39200 }
39201 return resultobj;
39202 fail:
39203 {
39204 if (temp2)
39205 delete arg2;
39206 }
39207 return NULL;
39208 }
39209
39210
39211 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39212 PyObject *resultobj = 0;
39213 wxWindow *arg1 = (wxWindow *) 0 ;
39214 wxString *arg2 = 0 ;
39215 int *arg3 = (int *) 0 ;
39216 int *arg4 = (int *) 0 ;
39217 int *arg5 = (int *) 0 ;
39218 int *arg6 = (int *) 0 ;
39219 wxFont *arg7 = (wxFont *) NULL ;
39220 void *argp1 = 0 ;
39221 int res1 = 0 ;
39222 bool temp2 = false ;
39223 int temp3 ;
39224 int res3 = SWIG_TMPOBJ ;
39225 int temp4 ;
39226 int res4 = SWIG_TMPOBJ ;
39227 int temp5 ;
39228 int res5 = SWIG_TMPOBJ ;
39229 int temp6 ;
39230 int res6 = SWIG_TMPOBJ ;
39231 void *argp7 = 0 ;
39232 int res7 = 0 ;
39233 PyObject * obj0 = 0 ;
39234 PyObject * obj1 = 0 ;
39235 PyObject * obj2 = 0 ;
39236 char * kwnames[] = {
39237 (char *) "self",(char *) "string",(char *) "font", NULL
39238 };
39239
39240 arg3 = &temp3;
39241 arg4 = &temp4;
39242 arg5 = &temp5;
39243 arg6 = &temp6;
39244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39246 if (!SWIG_IsOK(res1)) {
39247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39248 }
39249 arg1 = reinterpret_cast< wxWindow * >(argp1);
39250 {
39251 arg2 = wxString_in_helper(obj1);
39252 if (arg2 == NULL) SWIG_fail;
39253 temp2 = true;
39254 }
39255 if (obj2) {
39256 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39257 if (!SWIG_IsOK(res7)) {
39258 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39259 }
39260 arg7 = reinterpret_cast< wxFont * >(argp7);
39261 }
39262 {
39263 PyThreadState* __tstate = wxPyBeginAllowThreads();
39264 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39265 wxPyEndAllowThreads(__tstate);
39266 if (PyErr_Occurred()) SWIG_fail;
39267 }
39268 resultobj = SWIG_Py_Void();
39269 if (SWIG_IsTmpObj(res3)) {
39270 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39271 } else {
39272 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39274 }
39275 if (SWIG_IsTmpObj(res4)) {
39276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39277 } else {
39278 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39280 }
39281 if (SWIG_IsTmpObj(res5)) {
39282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39283 } else {
39284 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39286 }
39287 if (SWIG_IsTmpObj(res6)) {
39288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39289 } else {
39290 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39292 }
39293 {
39294 if (temp2)
39295 delete arg2;
39296 }
39297 return resultobj;
39298 fail:
39299 {
39300 if (temp2)
39301 delete arg2;
39302 }
39303 return NULL;
39304 }
39305
39306
39307 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39308 PyObject *resultobj = 0;
39309 wxWindow *arg1 = (wxWindow *) 0 ;
39310 int *arg2 = (int *) 0 ;
39311 int *arg3 = (int *) 0 ;
39312 void *argp1 = 0 ;
39313 int res1 = 0 ;
39314 int temp2 ;
39315 int res2 = 0 ;
39316 int temp3 ;
39317 int res3 = 0 ;
39318 PyObject * obj0 = 0 ;
39319 PyObject * obj1 = 0 ;
39320 PyObject * obj2 = 0 ;
39321 char * kwnames[] = {
39322 (char *) "self",(char *) "x",(char *) "y", NULL
39323 };
39324
39325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39327 if (!SWIG_IsOK(res1)) {
39328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39329 }
39330 arg1 = reinterpret_cast< wxWindow * >(argp1);
39331 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39332 int val;
39333 int ecode = SWIG_AsVal_int(obj1, &val);
39334 if (!SWIG_IsOK(ecode)) {
39335 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39336 }
39337 temp2 = static_cast< int >(val);
39338 arg2 = &temp2;
39339 res2 = SWIG_AddTmpMask(ecode);
39340 }
39341 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39342 int val;
39343 int ecode = SWIG_AsVal_int(obj2, &val);
39344 if (!SWIG_IsOK(ecode)) {
39345 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39346 }
39347 temp3 = static_cast< int >(val);
39348 arg3 = &temp3;
39349 res3 = SWIG_AddTmpMask(ecode);
39350 }
39351 {
39352 PyThreadState* __tstate = wxPyBeginAllowThreads();
39353 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39354 wxPyEndAllowThreads(__tstate);
39355 if (PyErr_Occurred()) SWIG_fail;
39356 }
39357 resultobj = SWIG_Py_Void();
39358 if (SWIG_IsTmpObj(res2)) {
39359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39360 } else {
39361 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39363 }
39364 if (SWIG_IsTmpObj(res3)) {
39365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39366 } else {
39367 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39369 }
39370 return resultobj;
39371 fail:
39372 return NULL;
39373 }
39374
39375
39376 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39377 PyObject *resultobj = 0;
39378 wxWindow *arg1 = (wxWindow *) 0 ;
39379 int *arg2 = (int *) 0 ;
39380 int *arg3 = (int *) 0 ;
39381 void *argp1 = 0 ;
39382 int res1 = 0 ;
39383 int temp2 ;
39384 int res2 = 0 ;
39385 int temp3 ;
39386 int res3 = 0 ;
39387 PyObject * obj0 = 0 ;
39388 PyObject * obj1 = 0 ;
39389 PyObject * obj2 = 0 ;
39390 char * kwnames[] = {
39391 (char *) "self",(char *) "x",(char *) "y", NULL
39392 };
39393
39394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39396 if (!SWIG_IsOK(res1)) {
39397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39398 }
39399 arg1 = reinterpret_cast< wxWindow * >(argp1);
39400 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39401 int val;
39402 int ecode = SWIG_AsVal_int(obj1, &val);
39403 if (!SWIG_IsOK(ecode)) {
39404 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39405 }
39406 temp2 = static_cast< int >(val);
39407 arg2 = &temp2;
39408 res2 = SWIG_AddTmpMask(ecode);
39409 }
39410 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39411 int val;
39412 int ecode = SWIG_AsVal_int(obj2, &val);
39413 if (!SWIG_IsOK(ecode)) {
39414 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39415 }
39416 temp3 = static_cast< int >(val);
39417 arg3 = &temp3;
39418 res3 = SWIG_AddTmpMask(ecode);
39419 }
39420 {
39421 PyThreadState* __tstate = wxPyBeginAllowThreads();
39422 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39423 wxPyEndAllowThreads(__tstate);
39424 if (PyErr_Occurred()) SWIG_fail;
39425 }
39426 resultobj = SWIG_Py_Void();
39427 if (SWIG_IsTmpObj(res2)) {
39428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39429 } else {
39430 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39431 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39432 }
39433 if (SWIG_IsTmpObj(res3)) {
39434 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39435 } else {
39436 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39437 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39438 }
39439 return resultobj;
39440 fail:
39441 return NULL;
39442 }
39443
39444
39445 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39446 PyObject *resultobj = 0;
39447 wxWindow *arg1 = (wxWindow *) 0 ;
39448 wxPoint *arg2 = 0 ;
39449 wxPoint result;
39450 void *argp1 = 0 ;
39451 int res1 = 0 ;
39452 wxPoint temp2 ;
39453 PyObject * obj0 = 0 ;
39454 PyObject * obj1 = 0 ;
39455 char * kwnames[] = {
39456 (char *) "self",(char *) "pt", NULL
39457 };
39458
39459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39461 if (!SWIG_IsOK(res1)) {
39462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39463 }
39464 arg1 = reinterpret_cast< wxWindow * >(argp1);
39465 {
39466 arg2 = &temp2;
39467 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39468 }
39469 {
39470 PyThreadState* __tstate = wxPyBeginAllowThreads();
39471 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39476 return resultobj;
39477 fail:
39478 return NULL;
39479 }
39480
39481
39482 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39483 PyObject *resultobj = 0;
39484 wxWindow *arg1 = (wxWindow *) 0 ;
39485 wxPoint *arg2 = 0 ;
39486 wxPoint result;
39487 void *argp1 = 0 ;
39488 int res1 = 0 ;
39489 wxPoint temp2 ;
39490 PyObject * obj0 = 0 ;
39491 PyObject * obj1 = 0 ;
39492 char * kwnames[] = {
39493 (char *) "self",(char *) "pt", NULL
39494 };
39495
39496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39498 if (!SWIG_IsOK(res1)) {
39499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39500 }
39501 arg1 = reinterpret_cast< wxWindow * >(argp1);
39502 {
39503 arg2 = &temp2;
39504 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39505 }
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39513 return resultobj;
39514 fail:
39515 return NULL;
39516 }
39517
39518
39519 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39520 PyObject *resultobj = 0;
39521 wxWindow *arg1 = (wxWindow *) 0 ;
39522 int arg2 ;
39523 int arg3 ;
39524 wxHitTest result;
39525 void *argp1 = 0 ;
39526 int res1 = 0 ;
39527 int val2 ;
39528 int ecode2 = 0 ;
39529 int val3 ;
39530 int ecode3 = 0 ;
39531 PyObject * obj0 = 0 ;
39532 PyObject * obj1 = 0 ;
39533 PyObject * obj2 = 0 ;
39534 char * kwnames[] = {
39535 (char *) "self",(char *) "x",(char *) "y", NULL
39536 };
39537
39538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) 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_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39542 }
39543 arg1 = reinterpret_cast< wxWindow * >(argp1);
39544 ecode2 = SWIG_AsVal_int(obj1, &val2);
39545 if (!SWIG_IsOK(ecode2)) {
39546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39547 }
39548 arg2 = static_cast< int >(val2);
39549 ecode3 = SWIG_AsVal_int(obj2, &val3);
39550 if (!SWIG_IsOK(ecode3)) {
39551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39552 }
39553 arg3 = static_cast< int >(val3);
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39557 wxPyEndAllowThreads(__tstate);
39558 if (PyErr_Occurred()) SWIG_fail;
39559 }
39560 resultobj = SWIG_From_int(static_cast< int >(result));
39561 return resultobj;
39562 fail:
39563 return NULL;
39564 }
39565
39566
39567 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj = 0;
39569 wxWindow *arg1 = (wxWindow *) 0 ;
39570 wxPoint *arg2 = 0 ;
39571 wxHitTest result;
39572 void *argp1 = 0 ;
39573 int res1 = 0 ;
39574 wxPoint temp2 ;
39575 PyObject * obj0 = 0 ;
39576 PyObject * obj1 = 0 ;
39577 char * kwnames[] = {
39578 (char *) "self",(char *) "pt", NULL
39579 };
39580
39581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39583 if (!SWIG_IsOK(res1)) {
39584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39585 }
39586 arg1 = reinterpret_cast< wxWindow * >(argp1);
39587 {
39588 arg2 = &temp2;
39589 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39590 }
39591 {
39592 PyThreadState* __tstate = wxPyBeginAllowThreads();
39593 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39594 wxPyEndAllowThreads(__tstate);
39595 if (PyErr_Occurred()) SWIG_fail;
39596 }
39597 resultobj = SWIG_From_int(static_cast< int >(result));
39598 return resultobj;
39599 fail:
39600 return NULL;
39601 }
39602
39603
39604 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39605 PyObject *resultobj = 0;
39606 wxWindow *arg1 = (wxWindow *) 0 ;
39607 long arg2 ;
39608 wxBorder result;
39609 void *argp1 = 0 ;
39610 int res1 = 0 ;
39611 long val2 ;
39612 int ecode2 = 0 ;
39613
39614 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39616 if (!SWIG_IsOK(res1)) {
39617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39618 }
39619 arg1 = reinterpret_cast< wxWindow * >(argp1);
39620 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39621 if (!SWIG_IsOK(ecode2)) {
39622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39623 }
39624 arg2 = static_cast< long >(val2);
39625 {
39626 PyThreadState* __tstate = wxPyBeginAllowThreads();
39627 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39628 wxPyEndAllowThreads(__tstate);
39629 if (PyErr_Occurred()) SWIG_fail;
39630 }
39631 resultobj = SWIG_From_int(static_cast< int >(result));
39632 return resultobj;
39633 fail:
39634 return NULL;
39635 }
39636
39637
39638 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39639 PyObject *resultobj = 0;
39640 wxWindow *arg1 = (wxWindow *) 0 ;
39641 wxBorder result;
39642 void *argp1 = 0 ;
39643 int res1 = 0 ;
39644
39645 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39647 if (!SWIG_IsOK(res1)) {
39648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39649 }
39650 arg1 = reinterpret_cast< wxWindow * >(argp1);
39651 {
39652 PyThreadState* __tstate = wxPyBeginAllowThreads();
39653 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39654 wxPyEndAllowThreads(__tstate);
39655 if (PyErr_Occurred()) SWIG_fail;
39656 }
39657 resultobj = SWIG_From_int(static_cast< int >(result));
39658 return resultobj;
39659 fail:
39660 return NULL;
39661 }
39662
39663
39664 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39665 int argc;
39666 PyObject *argv[3];
39667
39668 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39669 --argc;
39670 if (argc == 1) {
39671 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39672 }
39673 if (argc == 2) {
39674 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39675 }
39676
39677 fail:
39678 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39679 return NULL;
39680 }
39681
39682
39683 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39684 PyObject *resultobj = 0;
39685 wxWindow *arg1 = (wxWindow *) 0 ;
39686 long arg2 = (long) wxUPDATE_UI_NONE ;
39687 void *argp1 = 0 ;
39688 int res1 = 0 ;
39689 long val2 ;
39690 int ecode2 = 0 ;
39691 PyObject * obj0 = 0 ;
39692 PyObject * obj1 = 0 ;
39693 char * kwnames[] = {
39694 (char *) "self",(char *) "flags", NULL
39695 };
39696
39697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39699 if (!SWIG_IsOK(res1)) {
39700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39701 }
39702 arg1 = reinterpret_cast< wxWindow * >(argp1);
39703 if (obj1) {
39704 ecode2 = SWIG_AsVal_long(obj1, &val2);
39705 if (!SWIG_IsOK(ecode2)) {
39706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39707 }
39708 arg2 = static_cast< long >(val2);
39709 }
39710 {
39711 PyThreadState* __tstate = wxPyBeginAllowThreads();
39712 (arg1)->UpdateWindowUI(arg2);
39713 wxPyEndAllowThreads(__tstate);
39714 if (PyErr_Occurred()) SWIG_fail;
39715 }
39716 resultobj = SWIG_Py_Void();
39717 return resultobj;
39718 fail:
39719 return NULL;
39720 }
39721
39722
39723 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39724 PyObject *resultobj = 0;
39725 wxWindow *arg1 = (wxWindow *) 0 ;
39726 wxMenu *arg2 = (wxMenu *) 0 ;
39727 int arg3 = (int) -1 ;
39728 int arg4 = (int) -1 ;
39729 bool result;
39730 void *argp1 = 0 ;
39731 int res1 = 0 ;
39732 void *argp2 = 0 ;
39733 int res2 = 0 ;
39734 int val3 ;
39735 int ecode3 = 0 ;
39736 int val4 ;
39737 int ecode4 = 0 ;
39738 PyObject * obj0 = 0 ;
39739 PyObject * obj1 = 0 ;
39740 PyObject * obj2 = 0 ;
39741 PyObject * obj3 = 0 ;
39742 char * kwnames[] = {
39743 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39744 };
39745
39746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39748 if (!SWIG_IsOK(res1)) {
39749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39750 }
39751 arg1 = reinterpret_cast< wxWindow * >(argp1);
39752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39753 if (!SWIG_IsOK(res2)) {
39754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39755 }
39756 arg2 = reinterpret_cast< wxMenu * >(argp2);
39757 if (obj2) {
39758 ecode3 = SWIG_AsVal_int(obj2, &val3);
39759 if (!SWIG_IsOK(ecode3)) {
39760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39761 }
39762 arg3 = static_cast< int >(val3);
39763 }
39764 if (obj3) {
39765 ecode4 = SWIG_AsVal_int(obj3, &val4);
39766 if (!SWIG_IsOK(ecode4)) {
39767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39768 }
39769 arg4 = static_cast< int >(val4);
39770 }
39771 {
39772 PyThreadState* __tstate = wxPyBeginAllowThreads();
39773 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39774 wxPyEndAllowThreads(__tstate);
39775 if (PyErr_Occurred()) SWIG_fail;
39776 }
39777 {
39778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39779 }
39780 return resultobj;
39781 fail:
39782 return NULL;
39783 }
39784
39785
39786 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39787 PyObject *resultobj = 0;
39788 wxWindow *arg1 = (wxWindow *) 0 ;
39789 wxMenu *arg2 = (wxMenu *) 0 ;
39790 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39791 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39792 bool result;
39793 void *argp1 = 0 ;
39794 int res1 = 0 ;
39795 void *argp2 = 0 ;
39796 int res2 = 0 ;
39797 wxPoint temp3 ;
39798 PyObject * obj0 = 0 ;
39799 PyObject * obj1 = 0 ;
39800 PyObject * obj2 = 0 ;
39801 char * kwnames[] = {
39802 (char *) "self",(char *) "menu",(char *) "pos", NULL
39803 };
39804
39805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39807 if (!SWIG_IsOK(res1)) {
39808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39809 }
39810 arg1 = reinterpret_cast< wxWindow * >(argp1);
39811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39812 if (!SWIG_IsOK(res2)) {
39813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39814 }
39815 arg2 = reinterpret_cast< wxMenu * >(argp2);
39816 if (obj2) {
39817 {
39818 arg3 = &temp3;
39819 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39820 }
39821 }
39822 {
39823 PyThreadState* __tstate = wxPyBeginAllowThreads();
39824 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39825 wxPyEndAllowThreads(__tstate);
39826 if (PyErr_Occurred()) SWIG_fail;
39827 }
39828 {
39829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39830 }
39831 return resultobj;
39832 fail:
39833 return NULL;
39834 }
39835
39836
39837 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39838 PyObject *resultobj = 0;
39839 wxWindow *arg1 = (wxWindow *) 0 ;
39840 bool result;
39841 void *argp1 = 0 ;
39842 int res1 = 0 ;
39843 PyObject *swig_obj[1] ;
39844
39845 if (!args) SWIG_fail;
39846 swig_obj[0] = args;
39847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39848 if (!SWIG_IsOK(res1)) {
39849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39850 }
39851 arg1 = reinterpret_cast< wxWindow * >(argp1);
39852 {
39853 PyThreadState* __tstate = wxPyBeginAllowThreads();
39854 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 {
39859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39860 }
39861 return resultobj;
39862 fail:
39863 return NULL;
39864 }
39865
39866
39867 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39868 PyObject *resultobj = 0;
39869 wxWindow *arg1 = (wxWindow *) 0 ;
39870 long result;
39871 void *argp1 = 0 ;
39872 int res1 = 0 ;
39873 PyObject *swig_obj[1] ;
39874
39875 if (!args) SWIG_fail;
39876 swig_obj[0] = args;
39877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39878 if (!SWIG_IsOK(res1)) {
39879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39880 }
39881 arg1 = reinterpret_cast< wxWindow * >(argp1);
39882 {
39883 PyThreadState* __tstate = wxPyBeginAllowThreads();
39884 result = (long)wxWindow_GetHandle(arg1);
39885 wxPyEndAllowThreads(__tstate);
39886 if (PyErr_Occurred()) SWIG_fail;
39887 }
39888 resultobj = SWIG_From_long(static_cast< long >(result));
39889 return resultobj;
39890 fail:
39891 return NULL;
39892 }
39893
39894
39895 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39896 PyObject *resultobj = 0;
39897 wxWindow *arg1 = (wxWindow *) 0 ;
39898 long arg2 ;
39899 void *argp1 = 0 ;
39900 int res1 = 0 ;
39901 long val2 ;
39902 int ecode2 = 0 ;
39903 PyObject * obj0 = 0 ;
39904 PyObject * obj1 = 0 ;
39905 char * kwnames[] = {
39906 (char *) "self",(char *) "handle", NULL
39907 };
39908
39909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39911 if (!SWIG_IsOK(res1)) {
39912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39913 }
39914 arg1 = reinterpret_cast< wxWindow * >(argp1);
39915 ecode2 = SWIG_AsVal_long(obj1, &val2);
39916 if (!SWIG_IsOK(ecode2)) {
39917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39918 }
39919 arg2 = static_cast< long >(val2);
39920 {
39921 PyThreadState* __tstate = wxPyBeginAllowThreads();
39922 wxWindow_AssociateHandle(arg1,arg2);
39923 wxPyEndAllowThreads(__tstate);
39924 if (PyErr_Occurred()) SWIG_fail;
39925 }
39926 resultobj = SWIG_Py_Void();
39927 return resultobj;
39928 fail:
39929 return NULL;
39930 }
39931
39932
39933 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39934 PyObject *resultobj = 0;
39935 wxWindow *arg1 = (wxWindow *) 0 ;
39936 void *argp1 = 0 ;
39937 int res1 = 0 ;
39938 PyObject *swig_obj[1] ;
39939
39940 if (!args) SWIG_fail;
39941 swig_obj[0] = args;
39942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39943 if (!SWIG_IsOK(res1)) {
39944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39945 }
39946 arg1 = reinterpret_cast< wxWindow * >(argp1);
39947 {
39948 PyThreadState* __tstate = wxPyBeginAllowThreads();
39949 (arg1)->DissociateHandle();
39950 wxPyEndAllowThreads(__tstate);
39951 if (PyErr_Occurred()) SWIG_fail;
39952 }
39953 resultobj = SWIG_Py_Void();
39954 return resultobj;
39955 fail:
39956 return NULL;
39957 }
39958
39959
39960 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39961 PyObject *resultobj = 0;
39962 wxWindow *arg1 = (wxWindow *) 0 ;
39963 int arg2 ;
39964 bool result;
39965 void *argp1 = 0 ;
39966 int res1 = 0 ;
39967 int val2 ;
39968 int ecode2 = 0 ;
39969 PyObject * obj0 = 0 ;
39970 PyObject * obj1 = 0 ;
39971 char * kwnames[] = {
39972 (char *) "self",(char *) "orient", NULL
39973 };
39974
39975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39977 if (!SWIG_IsOK(res1)) {
39978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39979 }
39980 arg1 = reinterpret_cast< wxWindow * >(argp1);
39981 ecode2 = SWIG_AsVal_int(obj1, &val2);
39982 if (!SWIG_IsOK(ecode2)) {
39983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39984 }
39985 arg2 = static_cast< int >(val2);
39986 {
39987 PyThreadState* __tstate = wxPyBeginAllowThreads();
39988 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39989 wxPyEndAllowThreads(__tstate);
39990 if (PyErr_Occurred()) SWIG_fail;
39991 }
39992 {
39993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39994 }
39995 return resultobj;
39996 fail:
39997 return NULL;
39998 }
39999
40000
40001 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40002 PyObject *resultobj = 0;
40003 wxWindow *arg1 = (wxWindow *) 0 ;
40004 int arg2 ;
40005 int arg3 ;
40006 int arg4 ;
40007 int arg5 ;
40008 bool arg6 = (bool) true ;
40009 void *argp1 = 0 ;
40010 int res1 = 0 ;
40011 int val2 ;
40012 int ecode2 = 0 ;
40013 int val3 ;
40014 int ecode3 = 0 ;
40015 int val4 ;
40016 int ecode4 = 0 ;
40017 int val5 ;
40018 int ecode5 = 0 ;
40019 bool val6 ;
40020 int ecode6 = 0 ;
40021 PyObject * obj0 = 0 ;
40022 PyObject * obj1 = 0 ;
40023 PyObject * obj2 = 0 ;
40024 PyObject * obj3 = 0 ;
40025 PyObject * obj4 = 0 ;
40026 PyObject * obj5 = 0 ;
40027 char * kwnames[] = {
40028 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40029 };
40030
40031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40033 if (!SWIG_IsOK(res1)) {
40034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40035 }
40036 arg1 = reinterpret_cast< wxWindow * >(argp1);
40037 ecode2 = SWIG_AsVal_int(obj1, &val2);
40038 if (!SWIG_IsOK(ecode2)) {
40039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40040 }
40041 arg2 = static_cast< int >(val2);
40042 ecode3 = SWIG_AsVal_int(obj2, &val3);
40043 if (!SWIG_IsOK(ecode3)) {
40044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40045 }
40046 arg3 = static_cast< int >(val3);
40047 ecode4 = SWIG_AsVal_int(obj3, &val4);
40048 if (!SWIG_IsOK(ecode4)) {
40049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40050 }
40051 arg4 = static_cast< int >(val4);
40052 ecode5 = SWIG_AsVal_int(obj4, &val5);
40053 if (!SWIG_IsOK(ecode5)) {
40054 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40055 }
40056 arg5 = static_cast< int >(val5);
40057 if (obj5) {
40058 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40059 if (!SWIG_IsOK(ecode6)) {
40060 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40061 }
40062 arg6 = static_cast< bool >(val6);
40063 }
40064 {
40065 PyThreadState* __tstate = wxPyBeginAllowThreads();
40066 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40067 wxPyEndAllowThreads(__tstate);
40068 if (PyErr_Occurred()) SWIG_fail;
40069 }
40070 resultobj = SWIG_Py_Void();
40071 return resultobj;
40072 fail:
40073 return NULL;
40074 }
40075
40076
40077 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40078 PyObject *resultobj = 0;
40079 wxWindow *arg1 = (wxWindow *) 0 ;
40080 int arg2 ;
40081 int arg3 ;
40082 bool arg4 = (bool) true ;
40083 void *argp1 = 0 ;
40084 int res1 = 0 ;
40085 int val2 ;
40086 int ecode2 = 0 ;
40087 int val3 ;
40088 int ecode3 = 0 ;
40089 bool val4 ;
40090 int ecode4 = 0 ;
40091 PyObject * obj0 = 0 ;
40092 PyObject * obj1 = 0 ;
40093 PyObject * obj2 = 0 ;
40094 PyObject * obj3 = 0 ;
40095 char * kwnames[] = {
40096 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40097 };
40098
40099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40101 if (!SWIG_IsOK(res1)) {
40102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40103 }
40104 arg1 = reinterpret_cast< wxWindow * >(argp1);
40105 ecode2 = SWIG_AsVal_int(obj1, &val2);
40106 if (!SWIG_IsOK(ecode2)) {
40107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40108 }
40109 arg2 = static_cast< int >(val2);
40110 ecode3 = SWIG_AsVal_int(obj2, &val3);
40111 if (!SWIG_IsOK(ecode3)) {
40112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40113 }
40114 arg3 = static_cast< int >(val3);
40115 if (obj3) {
40116 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40117 if (!SWIG_IsOK(ecode4)) {
40118 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40119 }
40120 arg4 = static_cast< bool >(val4);
40121 }
40122 {
40123 PyThreadState* __tstate = wxPyBeginAllowThreads();
40124 (arg1)->SetScrollPos(arg2,arg3,arg4);
40125 wxPyEndAllowThreads(__tstate);
40126 if (PyErr_Occurred()) SWIG_fail;
40127 }
40128 resultobj = SWIG_Py_Void();
40129 return resultobj;
40130 fail:
40131 return NULL;
40132 }
40133
40134
40135 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40136 PyObject *resultobj = 0;
40137 wxWindow *arg1 = (wxWindow *) 0 ;
40138 int arg2 ;
40139 int result;
40140 void *argp1 = 0 ;
40141 int res1 = 0 ;
40142 int val2 ;
40143 int ecode2 = 0 ;
40144 PyObject * obj0 = 0 ;
40145 PyObject * obj1 = 0 ;
40146 char * kwnames[] = {
40147 (char *) "self",(char *) "orientation", NULL
40148 };
40149
40150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40152 if (!SWIG_IsOK(res1)) {
40153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40154 }
40155 arg1 = reinterpret_cast< wxWindow * >(argp1);
40156 ecode2 = SWIG_AsVal_int(obj1, &val2);
40157 if (!SWIG_IsOK(ecode2)) {
40158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40159 }
40160 arg2 = static_cast< int >(val2);
40161 {
40162 PyThreadState* __tstate = wxPyBeginAllowThreads();
40163 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40164 wxPyEndAllowThreads(__tstate);
40165 if (PyErr_Occurred()) SWIG_fail;
40166 }
40167 resultobj = SWIG_From_int(static_cast< int >(result));
40168 return resultobj;
40169 fail:
40170 return NULL;
40171 }
40172
40173
40174 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40175 PyObject *resultobj = 0;
40176 wxWindow *arg1 = (wxWindow *) 0 ;
40177 int arg2 ;
40178 int result;
40179 void *argp1 = 0 ;
40180 int res1 = 0 ;
40181 int val2 ;
40182 int ecode2 = 0 ;
40183 PyObject * obj0 = 0 ;
40184 PyObject * obj1 = 0 ;
40185 char * kwnames[] = {
40186 (char *) "self",(char *) "orientation", NULL
40187 };
40188
40189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40191 if (!SWIG_IsOK(res1)) {
40192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40193 }
40194 arg1 = reinterpret_cast< wxWindow * >(argp1);
40195 ecode2 = SWIG_AsVal_int(obj1, &val2);
40196 if (!SWIG_IsOK(ecode2)) {
40197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40198 }
40199 arg2 = static_cast< int >(val2);
40200 {
40201 PyThreadState* __tstate = wxPyBeginAllowThreads();
40202 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40203 wxPyEndAllowThreads(__tstate);
40204 if (PyErr_Occurred()) SWIG_fail;
40205 }
40206 resultobj = SWIG_From_int(static_cast< int >(result));
40207 return resultobj;
40208 fail:
40209 return NULL;
40210 }
40211
40212
40213 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40214 PyObject *resultobj = 0;
40215 wxWindow *arg1 = (wxWindow *) 0 ;
40216 int arg2 ;
40217 int result;
40218 void *argp1 = 0 ;
40219 int res1 = 0 ;
40220 int val2 ;
40221 int ecode2 = 0 ;
40222 PyObject * obj0 = 0 ;
40223 PyObject * obj1 = 0 ;
40224 char * kwnames[] = {
40225 (char *) "self",(char *) "orientation", NULL
40226 };
40227
40228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40230 if (!SWIG_IsOK(res1)) {
40231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40232 }
40233 arg1 = reinterpret_cast< wxWindow * >(argp1);
40234 ecode2 = SWIG_AsVal_int(obj1, &val2);
40235 if (!SWIG_IsOK(ecode2)) {
40236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40237 }
40238 arg2 = static_cast< int >(val2);
40239 {
40240 PyThreadState* __tstate = wxPyBeginAllowThreads();
40241 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40242 wxPyEndAllowThreads(__tstate);
40243 if (PyErr_Occurred()) SWIG_fail;
40244 }
40245 resultobj = SWIG_From_int(static_cast< int >(result));
40246 return resultobj;
40247 fail:
40248 return NULL;
40249 }
40250
40251
40252 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40253 PyObject *resultobj = 0;
40254 wxWindow *arg1 = (wxWindow *) 0 ;
40255 int arg2 ;
40256 int arg3 ;
40257 wxRect *arg4 = (wxRect *) NULL ;
40258 void *argp1 = 0 ;
40259 int res1 = 0 ;
40260 int val2 ;
40261 int ecode2 = 0 ;
40262 int val3 ;
40263 int ecode3 = 0 ;
40264 void *argp4 = 0 ;
40265 int res4 = 0 ;
40266 PyObject * obj0 = 0 ;
40267 PyObject * obj1 = 0 ;
40268 PyObject * obj2 = 0 ;
40269 PyObject * obj3 = 0 ;
40270 char * kwnames[] = {
40271 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40272 };
40273
40274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40278 }
40279 arg1 = reinterpret_cast< wxWindow * >(argp1);
40280 ecode2 = SWIG_AsVal_int(obj1, &val2);
40281 if (!SWIG_IsOK(ecode2)) {
40282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40283 }
40284 arg2 = static_cast< int >(val2);
40285 ecode3 = SWIG_AsVal_int(obj2, &val3);
40286 if (!SWIG_IsOK(ecode3)) {
40287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40288 }
40289 arg3 = static_cast< int >(val3);
40290 if (obj3) {
40291 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40292 if (!SWIG_IsOK(res4)) {
40293 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40294 }
40295 arg4 = reinterpret_cast< wxRect * >(argp4);
40296 }
40297 {
40298 PyThreadState* __tstate = wxPyBeginAllowThreads();
40299 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40300 wxPyEndAllowThreads(__tstate);
40301 if (PyErr_Occurred()) SWIG_fail;
40302 }
40303 resultobj = SWIG_Py_Void();
40304 return resultobj;
40305 fail:
40306 return NULL;
40307 }
40308
40309
40310 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj = 0;
40312 wxWindow *arg1 = (wxWindow *) 0 ;
40313 int arg2 ;
40314 bool result;
40315 void *argp1 = 0 ;
40316 int res1 = 0 ;
40317 int val2 ;
40318 int ecode2 = 0 ;
40319 PyObject * obj0 = 0 ;
40320 PyObject * obj1 = 0 ;
40321 char * kwnames[] = {
40322 (char *) "self",(char *) "lines", NULL
40323 };
40324
40325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40327 if (!SWIG_IsOK(res1)) {
40328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40329 }
40330 arg1 = reinterpret_cast< wxWindow * >(argp1);
40331 ecode2 = SWIG_AsVal_int(obj1, &val2);
40332 if (!SWIG_IsOK(ecode2)) {
40333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40334 }
40335 arg2 = static_cast< int >(val2);
40336 {
40337 PyThreadState* __tstate = wxPyBeginAllowThreads();
40338 result = (bool)(arg1)->ScrollLines(arg2);
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 {
40343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40344 }
40345 return resultobj;
40346 fail:
40347 return NULL;
40348 }
40349
40350
40351 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40352 PyObject *resultobj = 0;
40353 wxWindow *arg1 = (wxWindow *) 0 ;
40354 int arg2 ;
40355 bool result;
40356 void *argp1 = 0 ;
40357 int res1 = 0 ;
40358 int val2 ;
40359 int ecode2 = 0 ;
40360 PyObject * obj0 = 0 ;
40361 PyObject * obj1 = 0 ;
40362 char * kwnames[] = {
40363 (char *) "self",(char *) "pages", NULL
40364 };
40365
40366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40368 if (!SWIG_IsOK(res1)) {
40369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40370 }
40371 arg1 = reinterpret_cast< wxWindow * >(argp1);
40372 ecode2 = SWIG_AsVal_int(obj1, &val2);
40373 if (!SWIG_IsOK(ecode2)) {
40374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40375 }
40376 arg2 = static_cast< int >(val2);
40377 {
40378 PyThreadState* __tstate = wxPyBeginAllowThreads();
40379 result = (bool)(arg1)->ScrollPages(arg2);
40380 wxPyEndAllowThreads(__tstate);
40381 if (PyErr_Occurred()) SWIG_fail;
40382 }
40383 {
40384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40385 }
40386 return resultobj;
40387 fail:
40388 return NULL;
40389 }
40390
40391
40392 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40393 PyObject *resultobj = 0;
40394 wxWindow *arg1 = (wxWindow *) 0 ;
40395 bool result;
40396 void *argp1 = 0 ;
40397 int res1 = 0 ;
40398 PyObject *swig_obj[1] ;
40399
40400 if (!args) SWIG_fail;
40401 swig_obj[0] = args;
40402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40403 if (!SWIG_IsOK(res1)) {
40404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40405 }
40406 arg1 = reinterpret_cast< wxWindow * >(argp1);
40407 {
40408 PyThreadState* __tstate = wxPyBeginAllowThreads();
40409 result = (bool)(arg1)->LineUp();
40410 wxPyEndAllowThreads(__tstate);
40411 if (PyErr_Occurred()) SWIG_fail;
40412 }
40413 {
40414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40415 }
40416 return resultobj;
40417 fail:
40418 return NULL;
40419 }
40420
40421
40422 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40423 PyObject *resultobj = 0;
40424 wxWindow *arg1 = (wxWindow *) 0 ;
40425 bool result;
40426 void *argp1 = 0 ;
40427 int res1 = 0 ;
40428 PyObject *swig_obj[1] ;
40429
40430 if (!args) SWIG_fail;
40431 swig_obj[0] = args;
40432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40433 if (!SWIG_IsOK(res1)) {
40434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40435 }
40436 arg1 = reinterpret_cast< wxWindow * >(argp1);
40437 {
40438 PyThreadState* __tstate = wxPyBeginAllowThreads();
40439 result = (bool)(arg1)->LineDown();
40440 wxPyEndAllowThreads(__tstate);
40441 if (PyErr_Occurred()) SWIG_fail;
40442 }
40443 {
40444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40445 }
40446 return resultobj;
40447 fail:
40448 return NULL;
40449 }
40450
40451
40452 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40453 PyObject *resultobj = 0;
40454 wxWindow *arg1 = (wxWindow *) 0 ;
40455 bool result;
40456 void *argp1 = 0 ;
40457 int res1 = 0 ;
40458 PyObject *swig_obj[1] ;
40459
40460 if (!args) SWIG_fail;
40461 swig_obj[0] = args;
40462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40463 if (!SWIG_IsOK(res1)) {
40464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40465 }
40466 arg1 = reinterpret_cast< wxWindow * >(argp1);
40467 {
40468 PyThreadState* __tstate = wxPyBeginAllowThreads();
40469 result = (bool)(arg1)->PageUp();
40470 wxPyEndAllowThreads(__tstate);
40471 if (PyErr_Occurred()) SWIG_fail;
40472 }
40473 {
40474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40475 }
40476 return resultobj;
40477 fail:
40478 return NULL;
40479 }
40480
40481
40482 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40483 PyObject *resultobj = 0;
40484 wxWindow *arg1 = (wxWindow *) 0 ;
40485 bool result;
40486 void *argp1 = 0 ;
40487 int res1 = 0 ;
40488 PyObject *swig_obj[1] ;
40489
40490 if (!args) SWIG_fail;
40491 swig_obj[0] = args;
40492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40493 if (!SWIG_IsOK(res1)) {
40494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40495 }
40496 arg1 = reinterpret_cast< wxWindow * >(argp1);
40497 {
40498 PyThreadState* __tstate = wxPyBeginAllowThreads();
40499 result = (bool)(arg1)->PageDown();
40500 wxPyEndAllowThreads(__tstate);
40501 if (PyErr_Occurred()) SWIG_fail;
40502 }
40503 {
40504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40505 }
40506 return resultobj;
40507 fail:
40508 return NULL;
40509 }
40510
40511
40512 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40513 PyObject *resultobj = 0;
40514 wxWindow *arg1 = (wxWindow *) 0 ;
40515 wxString *arg2 = 0 ;
40516 void *argp1 = 0 ;
40517 int res1 = 0 ;
40518 bool temp2 = false ;
40519 PyObject * obj0 = 0 ;
40520 PyObject * obj1 = 0 ;
40521 char * kwnames[] = {
40522 (char *) "self",(char *) "text", NULL
40523 };
40524
40525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40527 if (!SWIG_IsOK(res1)) {
40528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40529 }
40530 arg1 = reinterpret_cast< wxWindow * >(argp1);
40531 {
40532 arg2 = wxString_in_helper(obj1);
40533 if (arg2 == NULL) SWIG_fail;
40534 temp2 = true;
40535 }
40536 {
40537 PyThreadState* __tstate = wxPyBeginAllowThreads();
40538 (arg1)->SetHelpText((wxString const &)*arg2);
40539 wxPyEndAllowThreads(__tstate);
40540 if (PyErr_Occurred()) SWIG_fail;
40541 }
40542 resultobj = SWIG_Py_Void();
40543 {
40544 if (temp2)
40545 delete arg2;
40546 }
40547 return resultobj;
40548 fail:
40549 {
40550 if (temp2)
40551 delete arg2;
40552 }
40553 return NULL;
40554 }
40555
40556
40557 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40558 PyObject *resultobj = 0;
40559 wxWindow *arg1 = (wxWindow *) 0 ;
40560 wxString *arg2 = 0 ;
40561 void *argp1 = 0 ;
40562 int res1 = 0 ;
40563 bool temp2 = false ;
40564 PyObject * obj0 = 0 ;
40565 PyObject * obj1 = 0 ;
40566 char * kwnames[] = {
40567 (char *) "self",(char *) "text", NULL
40568 };
40569
40570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40572 if (!SWIG_IsOK(res1)) {
40573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40574 }
40575 arg1 = reinterpret_cast< wxWindow * >(argp1);
40576 {
40577 arg2 = wxString_in_helper(obj1);
40578 if (arg2 == NULL) SWIG_fail;
40579 temp2 = true;
40580 }
40581 {
40582 PyThreadState* __tstate = wxPyBeginAllowThreads();
40583 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40584 wxPyEndAllowThreads(__tstate);
40585 if (PyErr_Occurred()) SWIG_fail;
40586 }
40587 resultobj = SWIG_Py_Void();
40588 {
40589 if (temp2)
40590 delete arg2;
40591 }
40592 return resultobj;
40593 fail:
40594 {
40595 if (temp2)
40596 delete arg2;
40597 }
40598 return NULL;
40599 }
40600
40601
40602 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40603 PyObject *resultobj = 0;
40604 wxWindow *arg1 = (wxWindow *) 0 ;
40605 wxPoint *arg2 = 0 ;
40606 wxHelpEvent::Origin arg3 ;
40607 wxString result;
40608 void *argp1 = 0 ;
40609 int res1 = 0 ;
40610 wxPoint temp2 ;
40611 void *argp3 ;
40612 int res3 = 0 ;
40613 PyObject * obj0 = 0 ;
40614 PyObject * obj1 = 0 ;
40615 PyObject * obj2 = 0 ;
40616 char * kwnames[] = {
40617 (char *) "self",(char *) "pt",(char *) "origin", NULL
40618 };
40619
40620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40622 if (!SWIG_IsOK(res1)) {
40623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40624 }
40625 arg1 = reinterpret_cast< wxWindow * >(argp1);
40626 {
40627 arg2 = &temp2;
40628 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40629 }
40630 {
40631 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40632 if (!SWIG_IsOK(res3)) {
40633 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40634 }
40635 if (!argp3) {
40636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40637 } else {
40638 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40639 arg3 = *temp;
40640 if (SWIG_IsNewObj(res3)) delete temp;
40641 }
40642 }
40643 {
40644 PyThreadState* __tstate = wxPyBeginAllowThreads();
40645 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40646 wxPyEndAllowThreads(__tstate);
40647 if (PyErr_Occurred()) SWIG_fail;
40648 }
40649 {
40650 #if wxUSE_UNICODE
40651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40652 #else
40653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40654 #endif
40655 }
40656 return resultobj;
40657 fail:
40658 return NULL;
40659 }
40660
40661
40662 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40663 PyObject *resultobj = 0;
40664 wxWindow *arg1 = (wxWindow *) 0 ;
40665 wxString result;
40666 void *argp1 = 0 ;
40667 int res1 = 0 ;
40668 PyObject *swig_obj[1] ;
40669
40670 if (!args) SWIG_fail;
40671 swig_obj[0] = args;
40672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40673 if (!SWIG_IsOK(res1)) {
40674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40675 }
40676 arg1 = reinterpret_cast< wxWindow * >(argp1);
40677 {
40678 PyThreadState* __tstate = wxPyBeginAllowThreads();
40679 result = ((wxWindow const *)arg1)->GetHelpText();
40680 wxPyEndAllowThreads(__tstate);
40681 if (PyErr_Occurred()) SWIG_fail;
40682 }
40683 {
40684 #if wxUSE_UNICODE
40685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40686 #else
40687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40688 #endif
40689 }
40690 return resultobj;
40691 fail:
40692 return NULL;
40693 }
40694
40695
40696 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40697 PyObject *resultobj = 0;
40698 wxWindow *arg1 = (wxWindow *) 0 ;
40699 wxString *arg2 = 0 ;
40700 void *argp1 = 0 ;
40701 int res1 = 0 ;
40702 bool temp2 = false ;
40703 PyObject * obj0 = 0 ;
40704 PyObject * obj1 = 0 ;
40705 char * kwnames[] = {
40706 (char *) "self",(char *) "tip", NULL
40707 };
40708
40709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40711 if (!SWIG_IsOK(res1)) {
40712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40713 }
40714 arg1 = reinterpret_cast< wxWindow * >(argp1);
40715 {
40716 arg2 = wxString_in_helper(obj1);
40717 if (arg2 == NULL) SWIG_fail;
40718 temp2 = true;
40719 }
40720 {
40721 PyThreadState* __tstate = wxPyBeginAllowThreads();
40722 (arg1)->SetToolTip((wxString const &)*arg2);
40723 wxPyEndAllowThreads(__tstate);
40724 if (PyErr_Occurred()) SWIG_fail;
40725 }
40726 resultobj = SWIG_Py_Void();
40727 {
40728 if (temp2)
40729 delete arg2;
40730 }
40731 return resultobj;
40732 fail:
40733 {
40734 if (temp2)
40735 delete arg2;
40736 }
40737 return NULL;
40738 }
40739
40740
40741 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40742 PyObject *resultobj = 0;
40743 wxWindow *arg1 = (wxWindow *) 0 ;
40744 wxToolTip *arg2 = (wxToolTip *) 0 ;
40745 void *argp1 = 0 ;
40746 int res1 = 0 ;
40747 int res2 = 0 ;
40748 PyObject * obj0 = 0 ;
40749 PyObject * obj1 = 0 ;
40750 char * kwnames[] = {
40751 (char *) "self",(char *) "tip", NULL
40752 };
40753
40754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40756 if (!SWIG_IsOK(res1)) {
40757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40758 }
40759 arg1 = reinterpret_cast< wxWindow * >(argp1);
40760 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40761 if (!SWIG_IsOK(res2)) {
40762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40763 }
40764 {
40765 PyThreadState* __tstate = wxPyBeginAllowThreads();
40766 (arg1)->SetToolTip(arg2);
40767 wxPyEndAllowThreads(__tstate);
40768 if (PyErr_Occurred()) SWIG_fail;
40769 }
40770 resultobj = SWIG_Py_Void();
40771 return resultobj;
40772 fail:
40773 return NULL;
40774 }
40775
40776
40777 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40778 PyObject *resultobj = 0;
40779 wxWindow *arg1 = (wxWindow *) 0 ;
40780 wxToolTip *result = 0 ;
40781 void *argp1 = 0 ;
40782 int res1 = 0 ;
40783 PyObject *swig_obj[1] ;
40784
40785 if (!args) SWIG_fail;
40786 swig_obj[0] = args;
40787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40788 if (!SWIG_IsOK(res1)) {
40789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40790 }
40791 arg1 = reinterpret_cast< wxWindow * >(argp1);
40792 {
40793 PyThreadState* __tstate = wxPyBeginAllowThreads();
40794 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40795 wxPyEndAllowThreads(__tstate);
40796 if (PyErr_Occurred()) SWIG_fail;
40797 }
40798 {
40799 resultobj = wxPyMake_wxObject(result, (bool)0);
40800 }
40801 return resultobj;
40802 fail:
40803 return NULL;
40804 }
40805
40806
40807 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40808 PyObject *resultobj = 0;
40809 wxWindow *arg1 = (wxWindow *) 0 ;
40810 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 int res2 = 0 ;
40814 PyObject * obj0 = 0 ;
40815 PyObject * obj1 = 0 ;
40816 char * kwnames[] = {
40817 (char *) "self",(char *) "dropTarget", NULL
40818 };
40819
40820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40822 if (!SWIG_IsOK(res1)) {
40823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40824 }
40825 arg1 = reinterpret_cast< wxWindow * >(argp1);
40826 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40827 if (!SWIG_IsOK(res2)) {
40828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40829 }
40830 {
40831 PyThreadState* __tstate = wxPyBeginAllowThreads();
40832 (arg1)->SetDropTarget(arg2);
40833 wxPyEndAllowThreads(__tstate);
40834 if (PyErr_Occurred()) SWIG_fail;
40835 }
40836 resultobj = SWIG_Py_Void();
40837 return resultobj;
40838 fail:
40839 return NULL;
40840 }
40841
40842
40843 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40844 PyObject *resultobj = 0;
40845 wxWindow *arg1 = (wxWindow *) 0 ;
40846 wxPyDropTarget *result = 0 ;
40847 void *argp1 = 0 ;
40848 int res1 = 0 ;
40849 PyObject *swig_obj[1] ;
40850
40851 if (!args) SWIG_fail;
40852 swig_obj[0] = args;
40853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40854 if (!SWIG_IsOK(res1)) {
40855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40856 }
40857 arg1 = reinterpret_cast< wxWindow * >(argp1);
40858 {
40859 PyThreadState* __tstate = wxPyBeginAllowThreads();
40860 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40861 wxPyEndAllowThreads(__tstate);
40862 if (PyErr_Occurred()) SWIG_fail;
40863 }
40864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40865 return resultobj;
40866 fail:
40867 return NULL;
40868 }
40869
40870
40871 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40872 PyObject *resultobj = 0;
40873 wxWindow *arg1 = (wxWindow *) 0 ;
40874 bool arg2 ;
40875 void *argp1 = 0 ;
40876 int res1 = 0 ;
40877 bool val2 ;
40878 int ecode2 = 0 ;
40879 PyObject * obj0 = 0 ;
40880 PyObject * obj1 = 0 ;
40881 char * kwnames[] = {
40882 (char *) "self",(char *) "accept", NULL
40883 };
40884
40885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40887 if (!SWIG_IsOK(res1)) {
40888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40889 }
40890 arg1 = reinterpret_cast< wxWindow * >(argp1);
40891 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40892 if (!SWIG_IsOK(ecode2)) {
40893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40894 }
40895 arg2 = static_cast< bool >(val2);
40896 {
40897 PyThreadState* __tstate = wxPyBeginAllowThreads();
40898 wxWindow_DragAcceptFiles(arg1,arg2);
40899 wxPyEndAllowThreads(__tstate);
40900 if (PyErr_Occurred()) SWIG_fail;
40901 }
40902 resultobj = SWIG_Py_Void();
40903 return resultobj;
40904 fail:
40905 return NULL;
40906 }
40907
40908
40909 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40910 PyObject *resultobj = 0;
40911 wxWindow *arg1 = (wxWindow *) 0 ;
40912 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40913 void *argp1 = 0 ;
40914 int res1 = 0 ;
40915 int res2 = 0 ;
40916 PyObject * obj0 = 0 ;
40917 PyObject * obj1 = 0 ;
40918 char * kwnames[] = {
40919 (char *) "self",(char *) "constraints", NULL
40920 };
40921
40922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40924 if (!SWIG_IsOK(res1)) {
40925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40926 }
40927 arg1 = reinterpret_cast< wxWindow * >(argp1);
40928 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40929 if (!SWIG_IsOK(res2)) {
40930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40931 }
40932 {
40933 PyThreadState* __tstate = wxPyBeginAllowThreads();
40934 (arg1)->SetConstraints(arg2);
40935 wxPyEndAllowThreads(__tstate);
40936 if (PyErr_Occurred()) SWIG_fail;
40937 }
40938 resultobj = SWIG_Py_Void();
40939 return resultobj;
40940 fail:
40941 return NULL;
40942 }
40943
40944
40945 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40946 PyObject *resultobj = 0;
40947 wxWindow *arg1 = (wxWindow *) 0 ;
40948 wxLayoutConstraints *result = 0 ;
40949 void *argp1 = 0 ;
40950 int res1 = 0 ;
40951 PyObject *swig_obj[1] ;
40952
40953 if (!args) SWIG_fail;
40954 swig_obj[0] = args;
40955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40956 if (!SWIG_IsOK(res1)) {
40957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40958 }
40959 arg1 = reinterpret_cast< wxWindow * >(argp1);
40960 {
40961 PyThreadState* __tstate = wxPyBeginAllowThreads();
40962 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40963 wxPyEndAllowThreads(__tstate);
40964 if (PyErr_Occurred()) SWIG_fail;
40965 }
40966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40967 return resultobj;
40968 fail:
40969 return NULL;
40970 }
40971
40972
40973 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40974 PyObject *resultobj = 0;
40975 wxWindow *arg1 = (wxWindow *) 0 ;
40976 bool arg2 ;
40977 void *argp1 = 0 ;
40978 int res1 = 0 ;
40979 bool val2 ;
40980 int ecode2 = 0 ;
40981 PyObject * obj0 = 0 ;
40982 PyObject * obj1 = 0 ;
40983 char * kwnames[] = {
40984 (char *) "self",(char *) "autoLayout", NULL
40985 };
40986
40987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40989 if (!SWIG_IsOK(res1)) {
40990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40991 }
40992 arg1 = reinterpret_cast< wxWindow * >(argp1);
40993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40994 if (!SWIG_IsOK(ecode2)) {
40995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40996 }
40997 arg2 = static_cast< bool >(val2);
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 (arg1)->SetAutoLayout(arg2);
41001 wxPyEndAllowThreads(__tstate);
41002 if (PyErr_Occurred()) SWIG_fail;
41003 }
41004 resultobj = SWIG_Py_Void();
41005 return resultobj;
41006 fail:
41007 return NULL;
41008 }
41009
41010
41011 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41012 PyObject *resultobj = 0;
41013 wxWindow *arg1 = (wxWindow *) 0 ;
41014 bool result;
41015 void *argp1 = 0 ;
41016 int res1 = 0 ;
41017 PyObject *swig_obj[1] ;
41018
41019 if (!args) SWIG_fail;
41020 swig_obj[0] = args;
41021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41022 if (!SWIG_IsOK(res1)) {
41023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41024 }
41025 arg1 = reinterpret_cast< wxWindow * >(argp1);
41026 {
41027 PyThreadState* __tstate = wxPyBeginAllowThreads();
41028 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41029 wxPyEndAllowThreads(__tstate);
41030 if (PyErr_Occurred()) SWIG_fail;
41031 }
41032 {
41033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41034 }
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41042 PyObject *resultobj = 0;
41043 wxWindow *arg1 = (wxWindow *) 0 ;
41044 bool result;
41045 void *argp1 = 0 ;
41046 int res1 = 0 ;
41047 PyObject *swig_obj[1] ;
41048
41049 if (!args) SWIG_fail;
41050 swig_obj[0] = args;
41051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41052 if (!SWIG_IsOK(res1)) {
41053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41054 }
41055 arg1 = reinterpret_cast< wxWindow * >(argp1);
41056 {
41057 PyThreadState* __tstate = wxPyBeginAllowThreads();
41058 result = (bool)(arg1)->Layout();
41059 wxPyEndAllowThreads(__tstate);
41060 if (PyErr_Occurred()) SWIG_fail;
41061 }
41062 {
41063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41064 }
41065 return resultobj;
41066 fail:
41067 return NULL;
41068 }
41069
41070
41071 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41072 PyObject *resultobj = 0;
41073 wxWindow *arg1 = (wxWindow *) 0 ;
41074 wxSizer *arg2 = (wxSizer *) 0 ;
41075 bool arg3 = (bool) true ;
41076 void *argp1 = 0 ;
41077 int res1 = 0 ;
41078 int res2 = 0 ;
41079 bool val3 ;
41080 int ecode3 = 0 ;
41081 PyObject * obj0 = 0 ;
41082 PyObject * obj1 = 0 ;
41083 PyObject * obj2 = 0 ;
41084 char * kwnames[] = {
41085 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41086 };
41087
41088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41090 if (!SWIG_IsOK(res1)) {
41091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41092 }
41093 arg1 = reinterpret_cast< wxWindow * >(argp1);
41094 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41095 if (!SWIG_IsOK(res2)) {
41096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41097 }
41098 if (obj2) {
41099 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41100 if (!SWIG_IsOK(ecode3)) {
41101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41102 }
41103 arg3 = static_cast< bool >(val3);
41104 }
41105 {
41106 PyThreadState* __tstate = wxPyBeginAllowThreads();
41107 (arg1)->SetSizer(arg2,arg3);
41108 wxPyEndAllowThreads(__tstate);
41109 if (PyErr_Occurred()) SWIG_fail;
41110 }
41111 resultobj = SWIG_Py_Void();
41112 return resultobj;
41113 fail:
41114 return NULL;
41115 }
41116
41117
41118 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41119 PyObject *resultobj = 0;
41120 wxWindow *arg1 = (wxWindow *) 0 ;
41121 wxSizer *arg2 = (wxSizer *) 0 ;
41122 bool arg3 = (bool) true ;
41123 void *argp1 = 0 ;
41124 int res1 = 0 ;
41125 int res2 = 0 ;
41126 bool val3 ;
41127 int ecode3 = 0 ;
41128 PyObject * obj0 = 0 ;
41129 PyObject * obj1 = 0 ;
41130 PyObject * obj2 = 0 ;
41131 char * kwnames[] = {
41132 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41133 };
41134
41135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41137 if (!SWIG_IsOK(res1)) {
41138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41139 }
41140 arg1 = reinterpret_cast< wxWindow * >(argp1);
41141 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41142 if (!SWIG_IsOK(res2)) {
41143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41144 }
41145 if (obj2) {
41146 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41147 if (!SWIG_IsOK(ecode3)) {
41148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41149 }
41150 arg3 = static_cast< bool >(val3);
41151 }
41152 {
41153 PyThreadState* __tstate = wxPyBeginAllowThreads();
41154 (arg1)->SetSizerAndFit(arg2,arg3);
41155 wxPyEndAllowThreads(__tstate);
41156 if (PyErr_Occurred()) SWIG_fail;
41157 }
41158 resultobj = SWIG_Py_Void();
41159 return resultobj;
41160 fail:
41161 return NULL;
41162 }
41163
41164
41165 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41166 PyObject *resultobj = 0;
41167 wxWindow *arg1 = (wxWindow *) 0 ;
41168 wxSizer *result = 0 ;
41169 void *argp1 = 0 ;
41170 int res1 = 0 ;
41171 PyObject *swig_obj[1] ;
41172
41173 if (!args) SWIG_fail;
41174 swig_obj[0] = args;
41175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41176 if (!SWIG_IsOK(res1)) {
41177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41178 }
41179 arg1 = reinterpret_cast< wxWindow * >(argp1);
41180 {
41181 PyThreadState* __tstate = wxPyBeginAllowThreads();
41182 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41183 wxPyEndAllowThreads(__tstate);
41184 if (PyErr_Occurred()) SWIG_fail;
41185 }
41186 {
41187 resultobj = wxPyMake_wxObject(result, (bool)0);
41188 }
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj = 0;
41197 wxWindow *arg1 = (wxWindow *) 0 ;
41198 wxSizer *arg2 = (wxSizer *) 0 ;
41199 void *argp1 = 0 ;
41200 int res1 = 0 ;
41201 void *argp2 = 0 ;
41202 int res2 = 0 ;
41203 PyObject * obj0 = 0 ;
41204 PyObject * obj1 = 0 ;
41205 char * kwnames[] = {
41206 (char *) "self",(char *) "sizer", NULL
41207 };
41208
41209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41211 if (!SWIG_IsOK(res1)) {
41212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41213 }
41214 arg1 = reinterpret_cast< wxWindow * >(argp1);
41215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41216 if (!SWIG_IsOK(res2)) {
41217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41218 }
41219 arg2 = reinterpret_cast< wxSizer * >(argp2);
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 (arg1)->SetContainingSizer(arg2);
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 resultobj = SWIG_Py_Void();
41227 return resultobj;
41228 fail:
41229 return NULL;
41230 }
41231
41232
41233 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41234 PyObject *resultobj = 0;
41235 wxWindow *arg1 = (wxWindow *) 0 ;
41236 wxSizer *result = 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 PyObject *swig_obj[1] ;
41240
41241 if (!args) SWIG_fail;
41242 swig_obj[0] = args;
41243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41244 if (!SWIG_IsOK(res1)) {
41245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41246 }
41247 arg1 = reinterpret_cast< wxWindow * >(argp1);
41248 {
41249 PyThreadState* __tstate = wxPyBeginAllowThreads();
41250 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41251 wxPyEndAllowThreads(__tstate);
41252 if (PyErr_Occurred()) SWIG_fail;
41253 }
41254 {
41255 resultobj = wxPyMake_wxObject(result, (bool)0);
41256 }
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41264 PyObject *resultobj = 0;
41265 wxWindow *arg1 = (wxWindow *) 0 ;
41266 void *argp1 = 0 ;
41267 int res1 = 0 ;
41268 PyObject *swig_obj[1] ;
41269
41270 if (!args) SWIG_fail;
41271 swig_obj[0] = args;
41272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41273 if (!SWIG_IsOK(res1)) {
41274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41275 }
41276 arg1 = reinterpret_cast< wxWindow * >(argp1);
41277 {
41278 PyThreadState* __tstate = wxPyBeginAllowThreads();
41279 (arg1)->InheritAttributes();
41280 wxPyEndAllowThreads(__tstate);
41281 if (PyErr_Occurred()) SWIG_fail;
41282 }
41283 resultobj = SWIG_Py_Void();
41284 return resultobj;
41285 fail:
41286 return NULL;
41287 }
41288
41289
41290 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41291 PyObject *resultobj = 0;
41292 wxWindow *arg1 = (wxWindow *) 0 ;
41293 bool result;
41294 void *argp1 = 0 ;
41295 int res1 = 0 ;
41296 PyObject *swig_obj[1] ;
41297
41298 if (!args) SWIG_fail;
41299 swig_obj[0] = args;
41300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41301 if (!SWIG_IsOK(res1)) {
41302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41303 }
41304 arg1 = reinterpret_cast< wxWindow * >(argp1);
41305 {
41306 PyThreadState* __tstate = wxPyBeginAllowThreads();
41307 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41308 wxPyEndAllowThreads(__tstate);
41309 if (PyErr_Occurred()) SWIG_fail;
41310 }
41311 {
41312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41313 }
41314 return resultobj;
41315 fail:
41316 return NULL;
41317 }
41318
41319
41320 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41321 PyObject *resultobj = 0;
41322 wxWindow *arg1 = (wxWindow *) 0 ;
41323 bool result;
41324 void *argp1 = 0 ;
41325 int res1 = 0 ;
41326 PyObject *swig_obj[1] ;
41327
41328 if (!args) SWIG_fail;
41329 swig_obj[0] = args;
41330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41331 if (!SWIG_IsOK(res1)) {
41332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41333 }
41334 arg1 = reinterpret_cast< wxWindow * >(argp1);
41335 {
41336 PyThreadState* __tstate = wxPyBeginAllowThreads();
41337 result = (bool)(arg1)->CanSetTransparent();
41338 wxPyEndAllowThreads(__tstate);
41339 if (PyErr_Occurred()) SWIG_fail;
41340 }
41341 {
41342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41343 }
41344 return resultobj;
41345 fail:
41346 return NULL;
41347 }
41348
41349
41350 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41351 PyObject *resultobj = 0;
41352 wxWindow *arg1 = (wxWindow *) 0 ;
41353 byte arg2 ;
41354 bool result;
41355 void *argp1 = 0 ;
41356 int res1 = 0 ;
41357 unsigned char val2 ;
41358 int ecode2 = 0 ;
41359 PyObject * obj0 = 0 ;
41360 PyObject * obj1 = 0 ;
41361 char * kwnames[] = {
41362 (char *) "self",(char *) "alpha", NULL
41363 };
41364
41365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41367 if (!SWIG_IsOK(res1)) {
41368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41369 }
41370 arg1 = reinterpret_cast< wxWindow * >(argp1);
41371 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41372 if (!SWIG_IsOK(ecode2)) {
41373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41374 }
41375 arg2 = static_cast< byte >(val2);
41376 {
41377 PyThreadState* __tstate = wxPyBeginAllowThreads();
41378 result = (bool)(arg1)->SetTransparent(arg2);
41379 wxPyEndAllowThreads(__tstate);
41380 if (PyErr_Occurred()) SWIG_fail;
41381 }
41382 {
41383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41384 }
41385 return resultobj;
41386 fail:
41387 return NULL;
41388 }
41389
41390
41391 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41392 PyObject *obj;
41393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41394 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41395 return SWIG_Py_Void();
41396 }
41397
41398 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41399 return SWIG_Python_InitShadowInstance(args);
41400 }
41401
41402 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41403 PyObject *resultobj = 0;
41404 long arg1 ;
41405 wxWindow *arg2 = (wxWindow *) NULL ;
41406 wxWindow *result = 0 ;
41407 long val1 ;
41408 int ecode1 = 0 ;
41409 void *argp2 = 0 ;
41410 int res2 = 0 ;
41411 PyObject * obj0 = 0 ;
41412 PyObject * obj1 = 0 ;
41413 char * kwnames[] = {
41414 (char *) "id",(char *) "parent", NULL
41415 };
41416
41417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41418 ecode1 = SWIG_AsVal_long(obj0, &val1);
41419 if (!SWIG_IsOK(ecode1)) {
41420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41421 }
41422 arg1 = static_cast< long >(val1);
41423 if (obj1) {
41424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41425 if (!SWIG_IsOK(res2)) {
41426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41427 }
41428 arg2 = reinterpret_cast< wxWindow * >(argp2);
41429 }
41430 {
41431 if (!wxPyCheckForApp()) SWIG_fail;
41432 PyThreadState* __tstate = wxPyBeginAllowThreads();
41433 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41434 wxPyEndAllowThreads(__tstate);
41435 if (PyErr_Occurred()) SWIG_fail;
41436 }
41437 {
41438 resultobj = wxPyMake_wxObject(result, 0);
41439 }
41440 return resultobj;
41441 fail:
41442 return NULL;
41443 }
41444
41445
41446 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41447 PyObject *resultobj = 0;
41448 wxString *arg1 = 0 ;
41449 wxWindow *arg2 = (wxWindow *) NULL ;
41450 wxWindow *result = 0 ;
41451 bool temp1 = false ;
41452 void *argp2 = 0 ;
41453 int res2 = 0 ;
41454 PyObject * obj0 = 0 ;
41455 PyObject * obj1 = 0 ;
41456 char * kwnames[] = {
41457 (char *) "name",(char *) "parent", NULL
41458 };
41459
41460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41461 {
41462 arg1 = wxString_in_helper(obj0);
41463 if (arg1 == NULL) SWIG_fail;
41464 temp1 = true;
41465 }
41466 if (obj1) {
41467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41468 if (!SWIG_IsOK(res2)) {
41469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41470 }
41471 arg2 = reinterpret_cast< wxWindow * >(argp2);
41472 }
41473 {
41474 if (!wxPyCheckForApp()) SWIG_fail;
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41477 wxPyEndAllowThreads(__tstate);
41478 if (PyErr_Occurred()) SWIG_fail;
41479 }
41480 {
41481 resultobj = wxPyMake_wxObject(result, 0);
41482 }
41483 {
41484 if (temp1)
41485 delete arg1;
41486 }
41487 return resultobj;
41488 fail:
41489 {
41490 if (temp1)
41491 delete arg1;
41492 }
41493 return NULL;
41494 }
41495
41496
41497 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41498 PyObject *resultobj = 0;
41499 wxString *arg1 = 0 ;
41500 wxWindow *arg2 = (wxWindow *) NULL ;
41501 wxWindow *result = 0 ;
41502 bool temp1 = false ;
41503 void *argp2 = 0 ;
41504 int res2 = 0 ;
41505 PyObject * obj0 = 0 ;
41506 PyObject * obj1 = 0 ;
41507 char * kwnames[] = {
41508 (char *) "label",(char *) "parent", NULL
41509 };
41510
41511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41512 {
41513 arg1 = wxString_in_helper(obj0);
41514 if (arg1 == NULL) SWIG_fail;
41515 temp1 = true;
41516 }
41517 if (obj1) {
41518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41519 if (!SWIG_IsOK(res2)) {
41520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41521 }
41522 arg2 = reinterpret_cast< wxWindow * >(argp2);
41523 }
41524 {
41525 if (!wxPyCheckForApp()) SWIG_fail;
41526 PyThreadState* __tstate = wxPyBeginAllowThreads();
41527 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41528 wxPyEndAllowThreads(__tstate);
41529 if (PyErr_Occurred()) SWIG_fail;
41530 }
41531 {
41532 resultobj = wxPyMake_wxObject(result, 0);
41533 }
41534 {
41535 if (temp1)
41536 delete arg1;
41537 }
41538 return resultobj;
41539 fail:
41540 {
41541 if (temp1)
41542 delete arg1;
41543 }
41544 return NULL;
41545 }
41546
41547
41548 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41549 PyObject *resultobj = 0;
41550 wxWindow *arg1 = (wxWindow *) 0 ;
41551 unsigned long arg2 ;
41552 wxWindow *result = 0 ;
41553 void *argp1 = 0 ;
41554 int res1 = 0 ;
41555 unsigned long val2 ;
41556 int ecode2 = 0 ;
41557 PyObject * obj0 = 0 ;
41558 PyObject * obj1 = 0 ;
41559 char * kwnames[] = {
41560 (char *) "parent",(char *) "_hWnd", NULL
41561 };
41562
41563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41565 if (!SWIG_IsOK(res1)) {
41566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41567 }
41568 arg1 = reinterpret_cast< wxWindow * >(argp1);
41569 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41570 if (!SWIG_IsOK(ecode2)) {
41571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41572 }
41573 arg2 = static_cast< unsigned long >(val2);
41574 {
41575 if (!wxPyCheckForApp()) SWIG_fail;
41576 PyThreadState* __tstate = wxPyBeginAllowThreads();
41577 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41578 wxPyEndAllowThreads(__tstate);
41579 if (PyErr_Occurred()) SWIG_fail;
41580 }
41581 {
41582 resultobj = wxPyMake_wxObject(result, 0);
41583 }
41584 return resultobj;
41585 fail:
41586 return NULL;
41587 }
41588
41589
41590 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41591 PyObject *resultobj = 0;
41592 PyObject *result = 0 ;
41593
41594 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41595 {
41596 PyThreadState* __tstate = wxPyBeginAllowThreads();
41597 result = (PyObject *)GetTopLevelWindows();
41598 wxPyEndAllowThreads(__tstate);
41599 if (PyErr_Occurred()) SWIG_fail;
41600 }
41601 resultobj = result;
41602 return resultobj;
41603 fail:
41604 return NULL;
41605 }
41606
41607
41608 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41609 PyObject *resultobj = 0;
41610 wxValidator *result = 0 ;
41611
41612 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41613 {
41614 PyThreadState* __tstate = wxPyBeginAllowThreads();
41615 result = (wxValidator *)new wxValidator();
41616 wxPyEndAllowThreads(__tstate);
41617 if (PyErr_Occurred()) SWIG_fail;
41618 }
41619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41620 return resultobj;
41621 fail:
41622 return NULL;
41623 }
41624
41625
41626 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41627 PyObject *resultobj = 0;
41628 wxValidator *arg1 = (wxValidator *) 0 ;
41629 wxValidator *result = 0 ;
41630 void *argp1 = 0 ;
41631 int res1 = 0 ;
41632 PyObject *swig_obj[1] ;
41633
41634 if (!args) SWIG_fail;
41635 swig_obj[0] = args;
41636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41639 }
41640 arg1 = reinterpret_cast< wxValidator * >(argp1);
41641 {
41642 PyThreadState* __tstate = wxPyBeginAllowThreads();
41643 result = (wxValidator *)(arg1)->Clone();
41644 wxPyEndAllowThreads(__tstate);
41645 if (PyErr_Occurred()) SWIG_fail;
41646 }
41647 {
41648 resultobj = wxPyMake_wxObject(result, 0);
41649 }
41650 return resultobj;
41651 fail:
41652 return NULL;
41653 }
41654
41655
41656 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41657 PyObject *resultobj = 0;
41658 wxValidator *arg1 = (wxValidator *) 0 ;
41659 wxWindow *arg2 = (wxWindow *) 0 ;
41660 bool result;
41661 void *argp1 = 0 ;
41662 int res1 = 0 ;
41663 void *argp2 = 0 ;
41664 int res2 = 0 ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 char * kwnames[] = {
41668 (char *) "self",(char *) "parent", NULL
41669 };
41670
41671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41673 if (!SWIG_IsOK(res1)) {
41674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41675 }
41676 arg1 = reinterpret_cast< wxValidator * >(argp1);
41677 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41678 if (!SWIG_IsOK(res2)) {
41679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41680 }
41681 arg2 = reinterpret_cast< wxWindow * >(argp2);
41682 {
41683 PyThreadState* __tstate = wxPyBeginAllowThreads();
41684 result = (bool)(arg1)->Validate(arg2);
41685 wxPyEndAllowThreads(__tstate);
41686 if (PyErr_Occurred()) SWIG_fail;
41687 }
41688 {
41689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41690 }
41691 return resultobj;
41692 fail:
41693 return NULL;
41694 }
41695
41696
41697 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41698 PyObject *resultobj = 0;
41699 wxValidator *arg1 = (wxValidator *) 0 ;
41700 bool result;
41701 void *argp1 = 0 ;
41702 int res1 = 0 ;
41703 PyObject *swig_obj[1] ;
41704
41705 if (!args) SWIG_fail;
41706 swig_obj[0] = args;
41707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41708 if (!SWIG_IsOK(res1)) {
41709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41710 }
41711 arg1 = reinterpret_cast< wxValidator * >(argp1);
41712 {
41713 PyThreadState* __tstate = wxPyBeginAllowThreads();
41714 result = (bool)(arg1)->TransferToWindow();
41715 wxPyEndAllowThreads(__tstate);
41716 if (PyErr_Occurred()) SWIG_fail;
41717 }
41718 {
41719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41720 }
41721 return resultobj;
41722 fail:
41723 return NULL;
41724 }
41725
41726
41727 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41728 PyObject *resultobj = 0;
41729 wxValidator *arg1 = (wxValidator *) 0 ;
41730 bool result;
41731 void *argp1 = 0 ;
41732 int res1 = 0 ;
41733 PyObject *swig_obj[1] ;
41734
41735 if (!args) SWIG_fail;
41736 swig_obj[0] = args;
41737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41738 if (!SWIG_IsOK(res1)) {
41739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41740 }
41741 arg1 = reinterpret_cast< wxValidator * >(argp1);
41742 {
41743 PyThreadState* __tstate = wxPyBeginAllowThreads();
41744 result = (bool)(arg1)->TransferFromWindow();
41745 wxPyEndAllowThreads(__tstate);
41746 if (PyErr_Occurred()) SWIG_fail;
41747 }
41748 {
41749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41750 }
41751 return resultobj;
41752 fail:
41753 return NULL;
41754 }
41755
41756
41757 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41758 PyObject *resultobj = 0;
41759 wxValidator *arg1 = (wxValidator *) 0 ;
41760 wxWindow *result = 0 ;
41761 void *argp1 = 0 ;
41762 int res1 = 0 ;
41763 PyObject *swig_obj[1] ;
41764
41765 if (!args) SWIG_fail;
41766 swig_obj[0] = args;
41767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41768 if (!SWIG_IsOK(res1)) {
41769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41770 }
41771 arg1 = reinterpret_cast< wxValidator * >(argp1);
41772 {
41773 PyThreadState* __tstate = wxPyBeginAllowThreads();
41774 result = (wxWindow *)(arg1)->GetWindow();
41775 wxPyEndAllowThreads(__tstate);
41776 if (PyErr_Occurred()) SWIG_fail;
41777 }
41778 {
41779 resultobj = wxPyMake_wxObject(result, 0);
41780 }
41781 return resultobj;
41782 fail:
41783 return NULL;
41784 }
41785
41786
41787 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41788 PyObject *resultobj = 0;
41789 wxValidator *arg1 = (wxValidator *) 0 ;
41790 wxWindow *arg2 = (wxWindow *) 0 ;
41791 void *argp1 = 0 ;
41792 int res1 = 0 ;
41793 void *argp2 = 0 ;
41794 int res2 = 0 ;
41795 PyObject * obj0 = 0 ;
41796 PyObject * obj1 = 0 ;
41797 char * kwnames[] = {
41798 (char *) "self",(char *) "window", NULL
41799 };
41800
41801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41803 if (!SWIG_IsOK(res1)) {
41804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41805 }
41806 arg1 = reinterpret_cast< wxValidator * >(argp1);
41807 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41808 if (!SWIG_IsOK(res2)) {
41809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41810 }
41811 arg2 = reinterpret_cast< wxWindow * >(argp2);
41812 {
41813 PyThreadState* __tstate = wxPyBeginAllowThreads();
41814 (arg1)->SetWindow(arg2);
41815 wxPyEndAllowThreads(__tstate);
41816 if (PyErr_Occurred()) SWIG_fail;
41817 }
41818 resultobj = SWIG_Py_Void();
41819 return resultobj;
41820 fail:
41821 return NULL;
41822 }
41823
41824
41825 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41826 PyObject *resultobj = 0;
41827 bool result;
41828
41829 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41830 {
41831 PyThreadState* __tstate = wxPyBeginAllowThreads();
41832 result = (bool)wxValidator::IsSilent();
41833 wxPyEndAllowThreads(__tstate);
41834 if (PyErr_Occurred()) SWIG_fail;
41835 }
41836 {
41837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41838 }
41839 return resultobj;
41840 fail:
41841 return NULL;
41842 }
41843
41844
41845 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41846 PyObject *resultobj = 0;
41847 int arg1 = (int) true ;
41848 int val1 ;
41849 int ecode1 = 0 ;
41850 PyObject * obj0 = 0 ;
41851 char * kwnames[] = {
41852 (char *) "doIt", NULL
41853 };
41854
41855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41856 if (obj0) {
41857 ecode1 = SWIG_AsVal_int(obj0, &val1);
41858 if (!SWIG_IsOK(ecode1)) {
41859 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41860 }
41861 arg1 = static_cast< int >(val1);
41862 }
41863 {
41864 PyThreadState* __tstate = wxPyBeginAllowThreads();
41865 wxValidator::SetBellOnError(arg1);
41866 wxPyEndAllowThreads(__tstate);
41867 if (PyErr_Occurred()) SWIG_fail;
41868 }
41869 resultobj = SWIG_Py_Void();
41870 return resultobj;
41871 fail:
41872 return NULL;
41873 }
41874
41875
41876 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41877 PyObject *obj;
41878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41879 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41880 return SWIG_Py_Void();
41881 }
41882
41883 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41884 return SWIG_Python_InitShadowInstance(args);
41885 }
41886
41887 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41888 PyObject *resultobj = 0;
41889 wxPyValidator *result = 0 ;
41890
41891 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41892 {
41893 PyThreadState* __tstate = wxPyBeginAllowThreads();
41894 result = (wxPyValidator *)new wxPyValidator();
41895 wxPyEndAllowThreads(__tstate);
41896 if (PyErr_Occurred()) SWIG_fail;
41897 }
41898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41899 return resultobj;
41900 fail:
41901 return NULL;
41902 }
41903
41904
41905 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41906 PyObject *resultobj = 0;
41907 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41908 PyObject *arg2 = (PyObject *) 0 ;
41909 PyObject *arg3 = (PyObject *) 0 ;
41910 int arg4 = (int) 1 ;
41911 void *argp1 = 0 ;
41912 int res1 = 0 ;
41913 int val4 ;
41914 int ecode4 = 0 ;
41915 PyObject * obj0 = 0 ;
41916 PyObject * obj1 = 0 ;
41917 PyObject * obj2 = 0 ;
41918 PyObject * obj3 = 0 ;
41919 char * kwnames[] = {
41920 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41921 };
41922
41923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41925 if (!SWIG_IsOK(res1)) {
41926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41927 }
41928 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41929 arg2 = obj1;
41930 arg3 = obj2;
41931 if (obj3) {
41932 ecode4 = SWIG_AsVal_int(obj3, &val4);
41933 if (!SWIG_IsOK(ecode4)) {
41934 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41935 }
41936 arg4 = static_cast< int >(val4);
41937 }
41938 {
41939 PyThreadState* __tstate = wxPyBeginAllowThreads();
41940 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41941 wxPyEndAllowThreads(__tstate);
41942 if (PyErr_Occurred()) SWIG_fail;
41943 }
41944 resultobj = SWIG_Py_Void();
41945 return resultobj;
41946 fail:
41947 return NULL;
41948 }
41949
41950
41951 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41952 PyObject *obj;
41953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41954 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41955 return SWIG_Py_Void();
41956 }
41957
41958 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41959 return SWIG_Python_InitShadowInstance(args);
41960 }
41961
41962 SWIGINTERN int DefaultValidator_set(PyObject *) {
41963 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41964 return 1;
41965 }
41966
41967
41968 SWIGINTERN PyObject *DefaultValidator_get(void) {
41969 PyObject *pyobj = 0;
41970
41971 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41972 return pyobj;
41973 }
41974
41975
41976 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41977 PyObject *resultobj = 0;
41978 wxString const &arg1_defvalue = wxPyEmptyString ;
41979 wxString *arg1 = (wxString *) &arg1_defvalue ;
41980 long arg2 = (long) 0 ;
41981 wxMenu *result = 0 ;
41982 bool temp1 = false ;
41983 long val2 ;
41984 int ecode2 = 0 ;
41985 PyObject * obj0 = 0 ;
41986 PyObject * obj1 = 0 ;
41987 char * kwnames[] = {
41988 (char *) "title",(char *) "style", NULL
41989 };
41990
41991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41992 if (obj0) {
41993 {
41994 arg1 = wxString_in_helper(obj0);
41995 if (arg1 == NULL) SWIG_fail;
41996 temp1 = true;
41997 }
41998 }
41999 if (obj1) {
42000 ecode2 = SWIG_AsVal_long(obj1, &val2);
42001 if (!SWIG_IsOK(ecode2)) {
42002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42003 }
42004 arg2 = static_cast< long >(val2);
42005 }
42006 {
42007 if (!wxPyCheckForApp()) SWIG_fail;
42008 PyThreadState* __tstate = wxPyBeginAllowThreads();
42009 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42010 wxPyEndAllowThreads(__tstate);
42011 if (PyErr_Occurred()) SWIG_fail;
42012 }
42013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42014 {
42015 if (temp1)
42016 delete arg1;
42017 }
42018 return resultobj;
42019 fail:
42020 {
42021 if (temp1)
42022 delete arg1;
42023 }
42024 return NULL;
42025 }
42026
42027
42028 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42029 PyObject *resultobj = 0;
42030 wxMenu *arg1 = (wxMenu *) 0 ;
42031 int arg2 ;
42032 wxString const &arg3_defvalue = wxPyEmptyString ;
42033 wxString *arg3 = (wxString *) &arg3_defvalue ;
42034 wxString const &arg4_defvalue = wxPyEmptyString ;
42035 wxString *arg4 = (wxString *) &arg4_defvalue ;
42036 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42037 wxMenuItem *result = 0 ;
42038 void *argp1 = 0 ;
42039 int res1 = 0 ;
42040 int val2 ;
42041 int ecode2 = 0 ;
42042 bool temp3 = false ;
42043 bool temp4 = false ;
42044 int val5 ;
42045 int ecode5 = 0 ;
42046 PyObject * obj0 = 0 ;
42047 PyObject * obj1 = 0 ;
42048 PyObject * obj2 = 0 ;
42049 PyObject * obj3 = 0 ;
42050 PyObject * obj4 = 0 ;
42051 char * kwnames[] = {
42052 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42053 };
42054
42055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42057 if (!SWIG_IsOK(res1)) {
42058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42059 }
42060 arg1 = reinterpret_cast< wxMenu * >(argp1);
42061 ecode2 = SWIG_AsVal_int(obj1, &val2);
42062 if (!SWIG_IsOK(ecode2)) {
42063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42064 }
42065 arg2 = static_cast< int >(val2);
42066 if (obj2) {
42067 {
42068 arg3 = wxString_in_helper(obj2);
42069 if (arg3 == NULL) SWIG_fail;
42070 temp3 = true;
42071 }
42072 }
42073 if (obj3) {
42074 {
42075 arg4 = wxString_in_helper(obj3);
42076 if (arg4 == NULL) SWIG_fail;
42077 temp4 = true;
42078 }
42079 }
42080 if (obj4) {
42081 ecode5 = SWIG_AsVal_int(obj4, &val5);
42082 if (!SWIG_IsOK(ecode5)) {
42083 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42084 }
42085 arg5 = static_cast< wxItemKind >(val5);
42086 }
42087 {
42088 PyThreadState* __tstate = wxPyBeginAllowThreads();
42089 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42090 wxPyEndAllowThreads(__tstate);
42091 if (PyErr_Occurred()) SWIG_fail;
42092 }
42093 {
42094 resultobj = wxPyMake_wxObject(result, (bool)0);
42095 }
42096 {
42097 if (temp3)
42098 delete arg3;
42099 }
42100 {
42101 if (temp4)
42102 delete arg4;
42103 }
42104 return resultobj;
42105 fail:
42106 {
42107 if (temp3)
42108 delete arg3;
42109 }
42110 {
42111 if (temp4)
42112 delete arg4;
42113 }
42114 return NULL;
42115 }
42116
42117
42118 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42119 PyObject *resultobj = 0;
42120 wxMenu *arg1 = (wxMenu *) 0 ;
42121 wxMenuItem *result = 0 ;
42122 void *argp1 = 0 ;
42123 int res1 = 0 ;
42124 PyObject *swig_obj[1] ;
42125
42126 if (!args) SWIG_fail;
42127 swig_obj[0] = args;
42128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42129 if (!SWIG_IsOK(res1)) {
42130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42131 }
42132 arg1 = reinterpret_cast< wxMenu * >(argp1);
42133 {
42134 PyThreadState* __tstate = wxPyBeginAllowThreads();
42135 result = (wxMenuItem *)(arg1)->AppendSeparator();
42136 wxPyEndAllowThreads(__tstate);
42137 if (PyErr_Occurred()) SWIG_fail;
42138 }
42139 {
42140 resultobj = wxPyMake_wxObject(result, (bool)0);
42141 }
42142 return resultobj;
42143 fail:
42144 return NULL;
42145 }
42146
42147
42148 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42149 PyObject *resultobj = 0;
42150 wxMenu *arg1 = (wxMenu *) 0 ;
42151 int arg2 ;
42152 wxString *arg3 = 0 ;
42153 wxString const &arg4_defvalue = wxPyEmptyString ;
42154 wxString *arg4 = (wxString *) &arg4_defvalue ;
42155 wxMenuItem *result = 0 ;
42156 void *argp1 = 0 ;
42157 int res1 = 0 ;
42158 int val2 ;
42159 int ecode2 = 0 ;
42160 bool temp3 = false ;
42161 bool temp4 = false ;
42162 PyObject * obj0 = 0 ;
42163 PyObject * obj1 = 0 ;
42164 PyObject * obj2 = 0 ;
42165 PyObject * obj3 = 0 ;
42166 char * kwnames[] = {
42167 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42168 };
42169
42170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42172 if (!SWIG_IsOK(res1)) {
42173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42174 }
42175 arg1 = reinterpret_cast< wxMenu * >(argp1);
42176 ecode2 = SWIG_AsVal_int(obj1, &val2);
42177 if (!SWIG_IsOK(ecode2)) {
42178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42179 }
42180 arg2 = static_cast< int >(val2);
42181 {
42182 arg3 = wxString_in_helper(obj2);
42183 if (arg3 == NULL) SWIG_fail;
42184 temp3 = true;
42185 }
42186 if (obj3) {
42187 {
42188 arg4 = wxString_in_helper(obj3);
42189 if (arg4 == NULL) SWIG_fail;
42190 temp4 = true;
42191 }
42192 }
42193 {
42194 PyThreadState* __tstate = wxPyBeginAllowThreads();
42195 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42196 wxPyEndAllowThreads(__tstate);
42197 if (PyErr_Occurred()) SWIG_fail;
42198 }
42199 {
42200 resultobj = wxPyMake_wxObject(result, (bool)0);
42201 }
42202 {
42203 if (temp3)
42204 delete arg3;
42205 }
42206 {
42207 if (temp4)
42208 delete arg4;
42209 }
42210 return resultobj;
42211 fail:
42212 {
42213 if (temp3)
42214 delete arg3;
42215 }
42216 {
42217 if (temp4)
42218 delete arg4;
42219 }
42220 return NULL;
42221 }
42222
42223
42224 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42225 PyObject *resultobj = 0;
42226 wxMenu *arg1 = (wxMenu *) 0 ;
42227 int arg2 ;
42228 wxString *arg3 = 0 ;
42229 wxString const &arg4_defvalue = wxPyEmptyString ;
42230 wxString *arg4 = (wxString *) &arg4_defvalue ;
42231 wxMenuItem *result = 0 ;
42232 void *argp1 = 0 ;
42233 int res1 = 0 ;
42234 int val2 ;
42235 int ecode2 = 0 ;
42236 bool temp3 = false ;
42237 bool temp4 = false ;
42238 PyObject * obj0 = 0 ;
42239 PyObject * obj1 = 0 ;
42240 PyObject * obj2 = 0 ;
42241 PyObject * obj3 = 0 ;
42242 char * kwnames[] = {
42243 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42244 };
42245
42246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42248 if (!SWIG_IsOK(res1)) {
42249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42250 }
42251 arg1 = reinterpret_cast< wxMenu * >(argp1);
42252 ecode2 = SWIG_AsVal_int(obj1, &val2);
42253 if (!SWIG_IsOK(ecode2)) {
42254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42255 }
42256 arg2 = static_cast< int >(val2);
42257 {
42258 arg3 = wxString_in_helper(obj2);
42259 if (arg3 == NULL) SWIG_fail;
42260 temp3 = true;
42261 }
42262 if (obj3) {
42263 {
42264 arg4 = wxString_in_helper(obj3);
42265 if (arg4 == NULL) SWIG_fail;
42266 temp4 = true;
42267 }
42268 }
42269 {
42270 PyThreadState* __tstate = wxPyBeginAllowThreads();
42271 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42272 wxPyEndAllowThreads(__tstate);
42273 if (PyErr_Occurred()) SWIG_fail;
42274 }
42275 {
42276 resultobj = wxPyMake_wxObject(result, (bool)0);
42277 }
42278 {
42279 if (temp3)
42280 delete arg3;
42281 }
42282 {
42283 if (temp4)
42284 delete arg4;
42285 }
42286 return resultobj;
42287 fail:
42288 {
42289 if (temp3)
42290 delete arg3;
42291 }
42292 {
42293 if (temp4)
42294 delete arg4;
42295 }
42296 return NULL;
42297 }
42298
42299
42300 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42301 PyObject *resultobj = 0;
42302 wxMenu *arg1 = (wxMenu *) 0 ;
42303 int arg2 ;
42304 wxString *arg3 = 0 ;
42305 wxMenu *arg4 = (wxMenu *) 0 ;
42306 wxString const &arg5_defvalue = wxPyEmptyString ;
42307 wxString *arg5 = (wxString *) &arg5_defvalue ;
42308 wxMenuItem *result = 0 ;
42309 void *argp1 = 0 ;
42310 int res1 = 0 ;
42311 int val2 ;
42312 int ecode2 = 0 ;
42313 bool temp3 = false ;
42314 void *argp4 = 0 ;
42315 int res4 = 0 ;
42316 bool temp5 = false ;
42317 PyObject * obj0 = 0 ;
42318 PyObject * obj1 = 0 ;
42319 PyObject * obj2 = 0 ;
42320 PyObject * obj3 = 0 ;
42321 PyObject * obj4 = 0 ;
42322 char * kwnames[] = {
42323 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42324 };
42325
42326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42328 if (!SWIG_IsOK(res1)) {
42329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42330 }
42331 arg1 = reinterpret_cast< wxMenu * >(argp1);
42332 ecode2 = SWIG_AsVal_int(obj1, &val2);
42333 if (!SWIG_IsOK(ecode2)) {
42334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42335 }
42336 arg2 = static_cast< int >(val2);
42337 {
42338 arg3 = wxString_in_helper(obj2);
42339 if (arg3 == NULL) SWIG_fail;
42340 temp3 = true;
42341 }
42342 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42343 if (!SWIG_IsOK(res4)) {
42344 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42345 }
42346 arg4 = reinterpret_cast< wxMenu * >(argp4);
42347 if (obj4) {
42348 {
42349 arg5 = wxString_in_helper(obj4);
42350 if (arg5 == NULL) SWIG_fail;
42351 temp5 = true;
42352 }
42353 }
42354 {
42355 PyThreadState* __tstate = wxPyBeginAllowThreads();
42356 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42357 wxPyEndAllowThreads(__tstate);
42358 if (PyErr_Occurred()) SWIG_fail;
42359 }
42360 {
42361 resultobj = wxPyMake_wxObject(result, (bool)0);
42362 }
42363 {
42364 if (temp3)
42365 delete arg3;
42366 }
42367 {
42368 if (temp5)
42369 delete arg5;
42370 }
42371 return resultobj;
42372 fail:
42373 {
42374 if (temp3)
42375 delete arg3;
42376 }
42377 {
42378 if (temp5)
42379 delete arg5;
42380 }
42381 return NULL;
42382 }
42383
42384
42385 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42386 PyObject *resultobj = 0;
42387 wxMenu *arg1 = (wxMenu *) 0 ;
42388 wxMenu *arg2 = (wxMenu *) 0 ;
42389 wxString *arg3 = 0 ;
42390 wxString const &arg4_defvalue = wxPyEmptyString ;
42391 wxString *arg4 = (wxString *) &arg4_defvalue ;
42392 wxMenuItem *result = 0 ;
42393 void *argp1 = 0 ;
42394 int res1 = 0 ;
42395 void *argp2 = 0 ;
42396 int res2 = 0 ;
42397 bool temp3 = false ;
42398 bool temp4 = false ;
42399 PyObject * obj0 = 0 ;
42400 PyObject * obj1 = 0 ;
42401 PyObject * obj2 = 0 ;
42402 PyObject * obj3 = 0 ;
42403 char * kwnames[] = {
42404 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42405 };
42406
42407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42409 if (!SWIG_IsOK(res1)) {
42410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42411 }
42412 arg1 = reinterpret_cast< wxMenu * >(argp1);
42413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42414 if (!SWIG_IsOK(res2)) {
42415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42416 }
42417 arg2 = reinterpret_cast< wxMenu * >(argp2);
42418 {
42419 arg3 = wxString_in_helper(obj2);
42420 if (arg3 == NULL) SWIG_fail;
42421 temp3 = true;
42422 }
42423 if (obj3) {
42424 {
42425 arg4 = wxString_in_helper(obj3);
42426 if (arg4 == NULL) SWIG_fail;
42427 temp4 = true;
42428 }
42429 }
42430 {
42431 PyThreadState* __tstate = wxPyBeginAllowThreads();
42432 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42433 wxPyEndAllowThreads(__tstate);
42434 if (PyErr_Occurred()) SWIG_fail;
42435 }
42436 {
42437 resultobj = wxPyMake_wxObject(result, (bool)0);
42438 }
42439 {
42440 if (temp3)
42441 delete arg3;
42442 }
42443 {
42444 if (temp4)
42445 delete arg4;
42446 }
42447 return resultobj;
42448 fail:
42449 {
42450 if (temp3)
42451 delete arg3;
42452 }
42453 {
42454 if (temp4)
42455 delete arg4;
42456 }
42457 return NULL;
42458 }
42459
42460
42461 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42462 PyObject *resultobj = 0;
42463 wxMenu *arg1 = (wxMenu *) 0 ;
42464 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42465 wxMenuItem *result = 0 ;
42466 void *argp1 = 0 ;
42467 int res1 = 0 ;
42468 int res2 = 0 ;
42469 PyObject * obj0 = 0 ;
42470 PyObject * obj1 = 0 ;
42471 char * kwnames[] = {
42472 (char *) "self",(char *) "item", NULL
42473 };
42474
42475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42477 if (!SWIG_IsOK(res1)) {
42478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42479 }
42480 arg1 = reinterpret_cast< wxMenu * >(argp1);
42481 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42482 if (!SWIG_IsOK(res2)) {
42483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42484 }
42485 {
42486 PyThreadState* __tstate = wxPyBeginAllowThreads();
42487 result = (wxMenuItem *)(arg1)->Append(arg2);
42488 wxPyEndAllowThreads(__tstate);
42489 if (PyErr_Occurred()) SWIG_fail;
42490 }
42491 {
42492 resultobj = wxPyMake_wxObject(result, (bool)0);
42493 }
42494 return resultobj;
42495 fail:
42496 return NULL;
42497 }
42498
42499
42500 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42501 PyObject *resultobj = 0;
42502 wxMenu *arg1 = (wxMenu *) 0 ;
42503 size_t arg2 ;
42504 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42505 wxMenuItem *result = 0 ;
42506 void *argp1 = 0 ;
42507 int res1 = 0 ;
42508 size_t val2 ;
42509 int ecode2 = 0 ;
42510 int res3 = 0 ;
42511 PyObject * obj0 = 0 ;
42512 PyObject * obj1 = 0 ;
42513 PyObject * obj2 = 0 ;
42514 char * kwnames[] = {
42515 (char *) "self",(char *) "pos",(char *) "item", NULL
42516 };
42517
42518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42520 if (!SWIG_IsOK(res1)) {
42521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42522 }
42523 arg1 = reinterpret_cast< wxMenu * >(argp1);
42524 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42525 if (!SWIG_IsOK(ecode2)) {
42526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42527 }
42528 arg2 = static_cast< size_t >(val2);
42529 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42530 if (!SWIG_IsOK(res3)) {
42531 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42532 }
42533 {
42534 PyThreadState* __tstate = wxPyBeginAllowThreads();
42535 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42536 wxPyEndAllowThreads(__tstate);
42537 if (PyErr_Occurred()) SWIG_fail;
42538 }
42539 {
42540 resultobj = wxPyMake_wxObject(result, (bool)0);
42541 }
42542 return resultobj;
42543 fail:
42544 return NULL;
42545 }
42546
42547
42548 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42549 PyObject *resultobj = 0;
42550 wxMenu *arg1 = (wxMenu *) 0 ;
42551 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42552 wxMenuItem *result = 0 ;
42553 void *argp1 = 0 ;
42554 int res1 = 0 ;
42555 int res2 = 0 ;
42556 PyObject * obj0 = 0 ;
42557 PyObject * obj1 = 0 ;
42558 char * kwnames[] = {
42559 (char *) "self",(char *) "item", NULL
42560 };
42561
42562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42564 if (!SWIG_IsOK(res1)) {
42565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42566 }
42567 arg1 = reinterpret_cast< wxMenu * >(argp1);
42568 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42569 if (!SWIG_IsOK(res2)) {
42570 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42571 }
42572 {
42573 PyThreadState* __tstate = wxPyBeginAllowThreads();
42574 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42575 wxPyEndAllowThreads(__tstate);
42576 if (PyErr_Occurred()) SWIG_fail;
42577 }
42578 {
42579 resultobj = wxPyMake_wxObject(result, (bool)0);
42580 }
42581 return resultobj;
42582 fail:
42583 return NULL;
42584 }
42585
42586
42587 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42588 PyObject *resultobj = 0;
42589 wxMenu *arg1 = (wxMenu *) 0 ;
42590 void *argp1 = 0 ;
42591 int res1 = 0 ;
42592 PyObject *swig_obj[1] ;
42593
42594 if (!args) SWIG_fail;
42595 swig_obj[0] = args;
42596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42597 if (!SWIG_IsOK(res1)) {
42598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42599 }
42600 arg1 = reinterpret_cast< wxMenu * >(argp1);
42601 {
42602 PyThreadState* __tstate = wxPyBeginAllowThreads();
42603 (arg1)->Break();
42604 wxPyEndAllowThreads(__tstate);
42605 if (PyErr_Occurred()) SWIG_fail;
42606 }
42607 resultobj = SWIG_Py_Void();
42608 return resultobj;
42609 fail:
42610 return NULL;
42611 }
42612
42613
42614 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42615 PyObject *resultobj = 0;
42616 wxMenu *arg1 = (wxMenu *) 0 ;
42617 size_t arg2 ;
42618 int arg3 ;
42619 wxString const &arg4_defvalue = wxPyEmptyString ;
42620 wxString *arg4 = (wxString *) &arg4_defvalue ;
42621 wxString const &arg5_defvalue = wxPyEmptyString ;
42622 wxString *arg5 = (wxString *) &arg5_defvalue ;
42623 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42624 wxMenuItem *result = 0 ;
42625 void *argp1 = 0 ;
42626 int res1 = 0 ;
42627 size_t val2 ;
42628 int ecode2 = 0 ;
42629 int val3 ;
42630 int ecode3 = 0 ;
42631 bool temp4 = false ;
42632 bool temp5 = false ;
42633 int val6 ;
42634 int ecode6 = 0 ;
42635 PyObject * obj0 = 0 ;
42636 PyObject * obj1 = 0 ;
42637 PyObject * obj2 = 0 ;
42638 PyObject * obj3 = 0 ;
42639 PyObject * obj4 = 0 ;
42640 PyObject * obj5 = 0 ;
42641 char * kwnames[] = {
42642 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42643 };
42644
42645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42647 if (!SWIG_IsOK(res1)) {
42648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42649 }
42650 arg1 = reinterpret_cast< wxMenu * >(argp1);
42651 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42652 if (!SWIG_IsOK(ecode2)) {
42653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42654 }
42655 arg2 = static_cast< size_t >(val2);
42656 ecode3 = SWIG_AsVal_int(obj2, &val3);
42657 if (!SWIG_IsOK(ecode3)) {
42658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42659 }
42660 arg3 = static_cast< int >(val3);
42661 if (obj3) {
42662 {
42663 arg4 = wxString_in_helper(obj3);
42664 if (arg4 == NULL) SWIG_fail;
42665 temp4 = true;
42666 }
42667 }
42668 if (obj4) {
42669 {
42670 arg5 = wxString_in_helper(obj4);
42671 if (arg5 == NULL) SWIG_fail;
42672 temp5 = true;
42673 }
42674 }
42675 if (obj5) {
42676 ecode6 = SWIG_AsVal_int(obj5, &val6);
42677 if (!SWIG_IsOK(ecode6)) {
42678 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42679 }
42680 arg6 = static_cast< wxItemKind >(val6);
42681 }
42682 {
42683 PyThreadState* __tstate = wxPyBeginAllowThreads();
42684 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42685 wxPyEndAllowThreads(__tstate);
42686 if (PyErr_Occurred()) SWIG_fail;
42687 }
42688 {
42689 resultobj = wxPyMake_wxObject(result, (bool)0);
42690 }
42691 {
42692 if (temp4)
42693 delete arg4;
42694 }
42695 {
42696 if (temp5)
42697 delete arg5;
42698 }
42699 return resultobj;
42700 fail:
42701 {
42702 if (temp4)
42703 delete arg4;
42704 }
42705 {
42706 if (temp5)
42707 delete arg5;
42708 }
42709 return NULL;
42710 }
42711
42712
42713 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42714 PyObject *resultobj = 0;
42715 wxMenu *arg1 = (wxMenu *) 0 ;
42716 size_t arg2 ;
42717 wxMenuItem *result = 0 ;
42718 void *argp1 = 0 ;
42719 int res1 = 0 ;
42720 size_t val2 ;
42721 int ecode2 = 0 ;
42722 PyObject * obj0 = 0 ;
42723 PyObject * obj1 = 0 ;
42724 char * kwnames[] = {
42725 (char *) "self",(char *) "pos", NULL
42726 };
42727
42728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42730 if (!SWIG_IsOK(res1)) {
42731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42732 }
42733 arg1 = reinterpret_cast< wxMenu * >(argp1);
42734 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42735 if (!SWIG_IsOK(ecode2)) {
42736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42737 }
42738 arg2 = static_cast< size_t >(val2);
42739 {
42740 PyThreadState* __tstate = wxPyBeginAllowThreads();
42741 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42742 wxPyEndAllowThreads(__tstate);
42743 if (PyErr_Occurred()) SWIG_fail;
42744 }
42745 {
42746 resultobj = wxPyMake_wxObject(result, (bool)0);
42747 }
42748 return resultobj;
42749 fail:
42750 return NULL;
42751 }
42752
42753
42754 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42755 PyObject *resultobj = 0;
42756 wxMenu *arg1 = (wxMenu *) 0 ;
42757 size_t arg2 ;
42758 int arg3 ;
42759 wxString *arg4 = 0 ;
42760 wxString const &arg5_defvalue = wxPyEmptyString ;
42761 wxString *arg5 = (wxString *) &arg5_defvalue ;
42762 wxMenuItem *result = 0 ;
42763 void *argp1 = 0 ;
42764 int res1 = 0 ;
42765 size_t val2 ;
42766 int ecode2 = 0 ;
42767 int val3 ;
42768 int ecode3 = 0 ;
42769 bool temp4 = false ;
42770 bool temp5 = false ;
42771 PyObject * obj0 = 0 ;
42772 PyObject * obj1 = 0 ;
42773 PyObject * obj2 = 0 ;
42774 PyObject * obj3 = 0 ;
42775 PyObject * obj4 = 0 ;
42776 char * kwnames[] = {
42777 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42778 };
42779
42780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42782 if (!SWIG_IsOK(res1)) {
42783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42784 }
42785 arg1 = reinterpret_cast< wxMenu * >(argp1);
42786 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42787 if (!SWIG_IsOK(ecode2)) {
42788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42789 }
42790 arg2 = static_cast< size_t >(val2);
42791 ecode3 = SWIG_AsVal_int(obj2, &val3);
42792 if (!SWIG_IsOK(ecode3)) {
42793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42794 }
42795 arg3 = static_cast< int >(val3);
42796 {
42797 arg4 = wxString_in_helper(obj3);
42798 if (arg4 == NULL) SWIG_fail;
42799 temp4 = true;
42800 }
42801 if (obj4) {
42802 {
42803 arg5 = wxString_in_helper(obj4);
42804 if (arg5 == NULL) SWIG_fail;
42805 temp5 = true;
42806 }
42807 }
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42811 wxPyEndAllowThreads(__tstate);
42812 if (PyErr_Occurred()) SWIG_fail;
42813 }
42814 {
42815 resultobj = wxPyMake_wxObject(result, (bool)0);
42816 }
42817 {
42818 if (temp4)
42819 delete arg4;
42820 }
42821 {
42822 if (temp5)
42823 delete arg5;
42824 }
42825 return resultobj;
42826 fail:
42827 {
42828 if (temp4)
42829 delete arg4;
42830 }
42831 {
42832 if (temp5)
42833 delete arg5;
42834 }
42835 return NULL;
42836 }
42837
42838
42839 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42840 PyObject *resultobj = 0;
42841 wxMenu *arg1 = (wxMenu *) 0 ;
42842 size_t arg2 ;
42843 int arg3 ;
42844 wxString *arg4 = 0 ;
42845 wxString const &arg5_defvalue = wxPyEmptyString ;
42846 wxString *arg5 = (wxString *) &arg5_defvalue ;
42847 wxMenuItem *result = 0 ;
42848 void *argp1 = 0 ;
42849 int res1 = 0 ;
42850 size_t val2 ;
42851 int ecode2 = 0 ;
42852 int val3 ;
42853 int ecode3 = 0 ;
42854 bool temp4 = false ;
42855 bool temp5 = false ;
42856 PyObject * obj0 = 0 ;
42857 PyObject * obj1 = 0 ;
42858 PyObject * obj2 = 0 ;
42859 PyObject * obj3 = 0 ;
42860 PyObject * obj4 = 0 ;
42861 char * kwnames[] = {
42862 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42863 };
42864
42865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42867 if (!SWIG_IsOK(res1)) {
42868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42869 }
42870 arg1 = reinterpret_cast< wxMenu * >(argp1);
42871 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42872 if (!SWIG_IsOK(ecode2)) {
42873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42874 }
42875 arg2 = static_cast< size_t >(val2);
42876 ecode3 = SWIG_AsVal_int(obj2, &val3);
42877 if (!SWIG_IsOK(ecode3)) {
42878 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42879 }
42880 arg3 = static_cast< int >(val3);
42881 {
42882 arg4 = wxString_in_helper(obj3);
42883 if (arg4 == NULL) SWIG_fail;
42884 temp4 = true;
42885 }
42886 if (obj4) {
42887 {
42888 arg5 = wxString_in_helper(obj4);
42889 if (arg5 == NULL) SWIG_fail;
42890 temp5 = true;
42891 }
42892 }
42893 {
42894 PyThreadState* __tstate = wxPyBeginAllowThreads();
42895 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42896 wxPyEndAllowThreads(__tstate);
42897 if (PyErr_Occurred()) SWIG_fail;
42898 }
42899 {
42900 resultobj = wxPyMake_wxObject(result, (bool)0);
42901 }
42902 {
42903 if (temp4)
42904 delete arg4;
42905 }
42906 {
42907 if (temp5)
42908 delete arg5;
42909 }
42910 return resultobj;
42911 fail:
42912 {
42913 if (temp4)
42914 delete arg4;
42915 }
42916 {
42917 if (temp5)
42918 delete arg5;
42919 }
42920 return NULL;
42921 }
42922
42923
42924 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42925 PyObject *resultobj = 0;
42926 wxMenu *arg1 = (wxMenu *) 0 ;
42927 size_t arg2 ;
42928 int arg3 ;
42929 wxString *arg4 = 0 ;
42930 wxMenu *arg5 = (wxMenu *) 0 ;
42931 wxString const &arg6_defvalue = wxPyEmptyString ;
42932 wxString *arg6 = (wxString *) &arg6_defvalue ;
42933 wxMenuItem *result = 0 ;
42934 void *argp1 = 0 ;
42935 int res1 = 0 ;
42936 size_t val2 ;
42937 int ecode2 = 0 ;
42938 int val3 ;
42939 int ecode3 = 0 ;
42940 bool temp4 = false ;
42941 void *argp5 = 0 ;
42942 int res5 = 0 ;
42943 bool temp6 = false ;
42944 PyObject * obj0 = 0 ;
42945 PyObject * obj1 = 0 ;
42946 PyObject * obj2 = 0 ;
42947 PyObject * obj3 = 0 ;
42948 PyObject * obj4 = 0 ;
42949 PyObject * obj5 = 0 ;
42950 char * kwnames[] = {
42951 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42952 };
42953
42954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42956 if (!SWIG_IsOK(res1)) {
42957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42958 }
42959 arg1 = reinterpret_cast< wxMenu * >(argp1);
42960 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42961 if (!SWIG_IsOK(ecode2)) {
42962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42963 }
42964 arg2 = static_cast< size_t >(val2);
42965 ecode3 = SWIG_AsVal_int(obj2, &val3);
42966 if (!SWIG_IsOK(ecode3)) {
42967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42968 }
42969 arg3 = static_cast< int >(val3);
42970 {
42971 arg4 = wxString_in_helper(obj3);
42972 if (arg4 == NULL) SWIG_fail;
42973 temp4 = true;
42974 }
42975 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42976 if (!SWIG_IsOK(res5)) {
42977 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42978 }
42979 arg5 = reinterpret_cast< wxMenu * >(argp5);
42980 if (obj5) {
42981 {
42982 arg6 = wxString_in_helper(obj5);
42983 if (arg6 == NULL) SWIG_fail;
42984 temp6 = true;
42985 }
42986 }
42987 {
42988 PyThreadState* __tstate = wxPyBeginAllowThreads();
42989 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42990 wxPyEndAllowThreads(__tstate);
42991 if (PyErr_Occurred()) SWIG_fail;
42992 }
42993 {
42994 resultobj = wxPyMake_wxObject(result, (bool)0);
42995 }
42996 {
42997 if (temp4)
42998 delete arg4;
42999 }
43000 {
43001 if (temp6)
43002 delete arg6;
43003 }
43004 return resultobj;
43005 fail:
43006 {
43007 if (temp4)
43008 delete arg4;
43009 }
43010 {
43011 if (temp6)
43012 delete arg6;
43013 }
43014 return NULL;
43015 }
43016
43017
43018 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43019 PyObject *resultobj = 0;
43020 wxMenu *arg1 = (wxMenu *) 0 ;
43021 int arg2 ;
43022 wxString const &arg3_defvalue = wxPyEmptyString ;
43023 wxString *arg3 = (wxString *) &arg3_defvalue ;
43024 wxString const &arg4_defvalue = wxPyEmptyString ;
43025 wxString *arg4 = (wxString *) &arg4_defvalue ;
43026 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43027 wxMenuItem *result = 0 ;
43028 void *argp1 = 0 ;
43029 int res1 = 0 ;
43030 int val2 ;
43031 int ecode2 = 0 ;
43032 bool temp3 = false ;
43033 bool temp4 = false ;
43034 int val5 ;
43035 int ecode5 = 0 ;
43036 PyObject * obj0 = 0 ;
43037 PyObject * obj1 = 0 ;
43038 PyObject * obj2 = 0 ;
43039 PyObject * obj3 = 0 ;
43040 PyObject * obj4 = 0 ;
43041 char * kwnames[] = {
43042 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43043 };
43044
43045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43047 if (!SWIG_IsOK(res1)) {
43048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43049 }
43050 arg1 = reinterpret_cast< wxMenu * >(argp1);
43051 ecode2 = SWIG_AsVal_int(obj1, &val2);
43052 if (!SWIG_IsOK(ecode2)) {
43053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43054 }
43055 arg2 = static_cast< int >(val2);
43056 if (obj2) {
43057 {
43058 arg3 = wxString_in_helper(obj2);
43059 if (arg3 == NULL) SWIG_fail;
43060 temp3 = true;
43061 }
43062 }
43063 if (obj3) {
43064 {
43065 arg4 = wxString_in_helper(obj3);
43066 if (arg4 == NULL) SWIG_fail;
43067 temp4 = true;
43068 }
43069 }
43070 if (obj4) {
43071 ecode5 = SWIG_AsVal_int(obj4, &val5);
43072 if (!SWIG_IsOK(ecode5)) {
43073 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43074 }
43075 arg5 = static_cast< wxItemKind >(val5);
43076 }
43077 {
43078 PyThreadState* __tstate = wxPyBeginAllowThreads();
43079 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43080 wxPyEndAllowThreads(__tstate);
43081 if (PyErr_Occurred()) SWIG_fail;
43082 }
43083 {
43084 resultobj = wxPyMake_wxObject(result, (bool)0);
43085 }
43086 {
43087 if (temp3)
43088 delete arg3;
43089 }
43090 {
43091 if (temp4)
43092 delete arg4;
43093 }
43094 return resultobj;
43095 fail:
43096 {
43097 if (temp3)
43098 delete arg3;
43099 }
43100 {
43101 if (temp4)
43102 delete arg4;
43103 }
43104 return NULL;
43105 }
43106
43107
43108 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43109 PyObject *resultobj = 0;
43110 wxMenu *arg1 = (wxMenu *) 0 ;
43111 wxMenuItem *result = 0 ;
43112 void *argp1 = 0 ;
43113 int res1 = 0 ;
43114 PyObject *swig_obj[1] ;
43115
43116 if (!args) SWIG_fail;
43117 swig_obj[0] = args;
43118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43119 if (!SWIG_IsOK(res1)) {
43120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43121 }
43122 arg1 = reinterpret_cast< wxMenu * >(argp1);
43123 {
43124 PyThreadState* __tstate = wxPyBeginAllowThreads();
43125 result = (wxMenuItem *)(arg1)->PrependSeparator();
43126 wxPyEndAllowThreads(__tstate);
43127 if (PyErr_Occurred()) SWIG_fail;
43128 }
43129 {
43130 resultobj = wxPyMake_wxObject(result, (bool)0);
43131 }
43132 return resultobj;
43133 fail:
43134 return NULL;
43135 }
43136
43137
43138 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43139 PyObject *resultobj = 0;
43140 wxMenu *arg1 = (wxMenu *) 0 ;
43141 int arg2 ;
43142 wxString *arg3 = 0 ;
43143 wxString const &arg4_defvalue = wxPyEmptyString ;
43144 wxString *arg4 = (wxString *) &arg4_defvalue ;
43145 wxMenuItem *result = 0 ;
43146 void *argp1 = 0 ;
43147 int res1 = 0 ;
43148 int val2 ;
43149 int ecode2 = 0 ;
43150 bool temp3 = false ;
43151 bool temp4 = false ;
43152 PyObject * obj0 = 0 ;
43153 PyObject * obj1 = 0 ;
43154 PyObject * obj2 = 0 ;
43155 PyObject * obj3 = 0 ;
43156 char * kwnames[] = {
43157 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43158 };
43159
43160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43162 if (!SWIG_IsOK(res1)) {
43163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43164 }
43165 arg1 = reinterpret_cast< wxMenu * >(argp1);
43166 ecode2 = SWIG_AsVal_int(obj1, &val2);
43167 if (!SWIG_IsOK(ecode2)) {
43168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43169 }
43170 arg2 = static_cast< int >(val2);
43171 {
43172 arg3 = wxString_in_helper(obj2);
43173 if (arg3 == NULL) SWIG_fail;
43174 temp3 = true;
43175 }
43176 if (obj3) {
43177 {
43178 arg4 = wxString_in_helper(obj3);
43179 if (arg4 == NULL) SWIG_fail;
43180 temp4 = true;
43181 }
43182 }
43183 {
43184 PyThreadState* __tstate = wxPyBeginAllowThreads();
43185 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43186 wxPyEndAllowThreads(__tstate);
43187 if (PyErr_Occurred()) SWIG_fail;
43188 }
43189 {
43190 resultobj = wxPyMake_wxObject(result, (bool)0);
43191 }
43192 {
43193 if (temp3)
43194 delete arg3;
43195 }
43196 {
43197 if (temp4)
43198 delete arg4;
43199 }
43200 return resultobj;
43201 fail:
43202 {
43203 if (temp3)
43204 delete arg3;
43205 }
43206 {
43207 if (temp4)
43208 delete arg4;
43209 }
43210 return NULL;
43211 }
43212
43213
43214 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43215 PyObject *resultobj = 0;
43216 wxMenu *arg1 = (wxMenu *) 0 ;
43217 int arg2 ;
43218 wxString *arg3 = 0 ;
43219 wxString const &arg4_defvalue = wxPyEmptyString ;
43220 wxString *arg4 = (wxString *) &arg4_defvalue ;
43221 wxMenuItem *result = 0 ;
43222 void *argp1 = 0 ;
43223 int res1 = 0 ;
43224 int val2 ;
43225 int ecode2 = 0 ;
43226 bool temp3 = false ;
43227 bool temp4 = false ;
43228 PyObject * obj0 = 0 ;
43229 PyObject * obj1 = 0 ;
43230 PyObject * obj2 = 0 ;
43231 PyObject * obj3 = 0 ;
43232 char * kwnames[] = {
43233 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43234 };
43235
43236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43238 if (!SWIG_IsOK(res1)) {
43239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43240 }
43241 arg1 = reinterpret_cast< wxMenu * >(argp1);
43242 ecode2 = SWIG_AsVal_int(obj1, &val2);
43243 if (!SWIG_IsOK(ecode2)) {
43244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43245 }
43246 arg2 = static_cast< int >(val2);
43247 {
43248 arg3 = wxString_in_helper(obj2);
43249 if (arg3 == NULL) SWIG_fail;
43250 temp3 = true;
43251 }
43252 if (obj3) {
43253 {
43254 arg4 = wxString_in_helper(obj3);
43255 if (arg4 == NULL) SWIG_fail;
43256 temp4 = true;
43257 }
43258 }
43259 {
43260 PyThreadState* __tstate = wxPyBeginAllowThreads();
43261 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43262 wxPyEndAllowThreads(__tstate);
43263 if (PyErr_Occurred()) SWIG_fail;
43264 }
43265 {
43266 resultobj = wxPyMake_wxObject(result, (bool)0);
43267 }
43268 {
43269 if (temp3)
43270 delete arg3;
43271 }
43272 {
43273 if (temp4)
43274 delete arg4;
43275 }
43276 return resultobj;
43277 fail:
43278 {
43279 if (temp3)
43280 delete arg3;
43281 }
43282 {
43283 if (temp4)
43284 delete arg4;
43285 }
43286 return NULL;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43291 PyObject *resultobj = 0;
43292 wxMenu *arg1 = (wxMenu *) 0 ;
43293 int arg2 ;
43294 wxString *arg3 = 0 ;
43295 wxMenu *arg4 = (wxMenu *) 0 ;
43296 wxString const &arg5_defvalue = wxPyEmptyString ;
43297 wxString *arg5 = (wxString *) &arg5_defvalue ;
43298 wxMenuItem *result = 0 ;
43299 void *argp1 = 0 ;
43300 int res1 = 0 ;
43301 int val2 ;
43302 int ecode2 = 0 ;
43303 bool temp3 = false ;
43304 void *argp4 = 0 ;
43305 int res4 = 0 ;
43306 bool temp5 = false ;
43307 PyObject * obj0 = 0 ;
43308 PyObject * obj1 = 0 ;
43309 PyObject * obj2 = 0 ;
43310 PyObject * obj3 = 0 ;
43311 PyObject * obj4 = 0 ;
43312 char * kwnames[] = {
43313 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43314 };
43315
43316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43318 if (!SWIG_IsOK(res1)) {
43319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43320 }
43321 arg1 = reinterpret_cast< wxMenu * >(argp1);
43322 ecode2 = SWIG_AsVal_int(obj1, &val2);
43323 if (!SWIG_IsOK(ecode2)) {
43324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43325 }
43326 arg2 = static_cast< int >(val2);
43327 {
43328 arg3 = wxString_in_helper(obj2);
43329 if (arg3 == NULL) SWIG_fail;
43330 temp3 = true;
43331 }
43332 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43333 if (!SWIG_IsOK(res4)) {
43334 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43335 }
43336 arg4 = reinterpret_cast< wxMenu * >(argp4);
43337 if (obj4) {
43338 {
43339 arg5 = wxString_in_helper(obj4);
43340 if (arg5 == NULL) SWIG_fail;
43341 temp5 = true;
43342 }
43343 }
43344 {
43345 PyThreadState* __tstate = wxPyBeginAllowThreads();
43346 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43347 wxPyEndAllowThreads(__tstate);
43348 if (PyErr_Occurred()) SWIG_fail;
43349 }
43350 {
43351 resultobj = wxPyMake_wxObject(result, (bool)0);
43352 }
43353 {
43354 if (temp3)
43355 delete arg3;
43356 }
43357 {
43358 if (temp5)
43359 delete arg5;
43360 }
43361 return resultobj;
43362 fail:
43363 {
43364 if (temp3)
43365 delete arg3;
43366 }
43367 {
43368 if (temp5)
43369 delete arg5;
43370 }
43371 return NULL;
43372 }
43373
43374
43375 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43376 PyObject *resultobj = 0;
43377 wxMenu *arg1 = (wxMenu *) 0 ;
43378 int arg2 ;
43379 wxMenuItem *result = 0 ;
43380 void *argp1 = 0 ;
43381 int res1 = 0 ;
43382 int val2 ;
43383 int ecode2 = 0 ;
43384 PyObject * obj0 = 0 ;
43385 PyObject * obj1 = 0 ;
43386 char * kwnames[] = {
43387 (char *) "self",(char *) "id", NULL
43388 };
43389
43390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43392 if (!SWIG_IsOK(res1)) {
43393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43394 }
43395 arg1 = reinterpret_cast< wxMenu * >(argp1);
43396 ecode2 = SWIG_AsVal_int(obj1, &val2);
43397 if (!SWIG_IsOK(ecode2)) {
43398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43399 }
43400 arg2 = static_cast< int >(val2);
43401 {
43402 PyThreadState* __tstate = wxPyBeginAllowThreads();
43403 result = (wxMenuItem *)(arg1)->Remove(arg2);
43404 wxPyEndAllowThreads(__tstate);
43405 if (PyErr_Occurred()) SWIG_fail;
43406 }
43407 {
43408 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43409 }
43410 return resultobj;
43411 fail:
43412 return NULL;
43413 }
43414
43415
43416 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43417 PyObject *resultobj = 0;
43418 wxMenu *arg1 = (wxMenu *) 0 ;
43419 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43420 wxMenuItem *result = 0 ;
43421 void *argp1 = 0 ;
43422 int res1 = 0 ;
43423 void *argp2 = 0 ;
43424 int res2 = 0 ;
43425 PyObject * obj0 = 0 ;
43426 PyObject * obj1 = 0 ;
43427 char * kwnames[] = {
43428 (char *) "self",(char *) "item", NULL
43429 };
43430
43431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43433 if (!SWIG_IsOK(res1)) {
43434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43435 }
43436 arg1 = reinterpret_cast< wxMenu * >(argp1);
43437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43438 if (!SWIG_IsOK(res2)) {
43439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43440 }
43441 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43442 {
43443 PyThreadState* __tstate = wxPyBeginAllowThreads();
43444 result = (wxMenuItem *)(arg1)->Remove(arg2);
43445 wxPyEndAllowThreads(__tstate);
43446 if (PyErr_Occurred()) SWIG_fail;
43447 }
43448 {
43449 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43450 }
43451 return resultobj;
43452 fail:
43453 return NULL;
43454 }
43455
43456
43457 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43458 PyObject *resultobj = 0;
43459 wxMenu *arg1 = (wxMenu *) 0 ;
43460 int arg2 ;
43461 bool result;
43462 void *argp1 = 0 ;
43463 int res1 = 0 ;
43464 int val2 ;
43465 int ecode2 = 0 ;
43466 PyObject * obj0 = 0 ;
43467 PyObject * obj1 = 0 ;
43468 char * kwnames[] = {
43469 (char *) "self",(char *) "id", NULL
43470 };
43471
43472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43474 if (!SWIG_IsOK(res1)) {
43475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43476 }
43477 arg1 = reinterpret_cast< wxMenu * >(argp1);
43478 ecode2 = SWIG_AsVal_int(obj1, &val2);
43479 if (!SWIG_IsOK(ecode2)) {
43480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43481 }
43482 arg2 = static_cast< int >(val2);
43483 {
43484 PyThreadState* __tstate = wxPyBeginAllowThreads();
43485 result = (bool)(arg1)->Delete(arg2);
43486 wxPyEndAllowThreads(__tstate);
43487 if (PyErr_Occurred()) SWIG_fail;
43488 }
43489 {
43490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43491 }
43492 return resultobj;
43493 fail:
43494 return NULL;
43495 }
43496
43497
43498 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43499 PyObject *resultobj = 0;
43500 wxMenu *arg1 = (wxMenu *) 0 ;
43501 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43502 bool result;
43503 void *argp1 = 0 ;
43504 int res1 = 0 ;
43505 void *argp2 = 0 ;
43506 int res2 = 0 ;
43507 PyObject * obj0 = 0 ;
43508 PyObject * obj1 = 0 ;
43509 char * kwnames[] = {
43510 (char *) "self",(char *) "item", NULL
43511 };
43512
43513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43515 if (!SWIG_IsOK(res1)) {
43516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43517 }
43518 arg1 = reinterpret_cast< wxMenu * >(argp1);
43519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43520 if (!SWIG_IsOK(res2)) {
43521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43522 }
43523 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43524 {
43525 PyThreadState* __tstate = wxPyBeginAllowThreads();
43526 result = (bool)(arg1)->Delete(arg2);
43527 wxPyEndAllowThreads(__tstate);
43528 if (PyErr_Occurred()) SWIG_fail;
43529 }
43530 {
43531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43532 }
43533 return resultobj;
43534 fail:
43535 return NULL;
43536 }
43537
43538
43539 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43540 PyObject *resultobj = 0;
43541 wxMenu *arg1 = (wxMenu *) 0 ;
43542 void *argp1 = 0 ;
43543 int res1 = 0 ;
43544 PyObject *swig_obj[1] ;
43545
43546 if (!args) SWIG_fail;
43547 swig_obj[0] = args;
43548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43549 if (!SWIG_IsOK(res1)) {
43550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43551 }
43552 arg1 = reinterpret_cast< wxMenu * >(argp1);
43553 {
43554 PyThreadState* __tstate = wxPyBeginAllowThreads();
43555 wxMenu_Destroy(arg1);
43556 wxPyEndAllowThreads(__tstate);
43557 if (PyErr_Occurred()) SWIG_fail;
43558 }
43559 resultobj = SWIG_Py_Void();
43560 return resultobj;
43561 fail:
43562 return NULL;
43563 }
43564
43565
43566 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43567 PyObject *resultobj = 0;
43568 wxMenu *arg1 = (wxMenu *) 0 ;
43569 int arg2 ;
43570 bool result;
43571 void *argp1 = 0 ;
43572 int res1 = 0 ;
43573 int val2 ;
43574 int ecode2 = 0 ;
43575 PyObject * obj0 = 0 ;
43576 PyObject * obj1 = 0 ;
43577 char * kwnames[] = {
43578 (char *) "self",(char *) "id", NULL
43579 };
43580
43581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43583 if (!SWIG_IsOK(res1)) {
43584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43585 }
43586 arg1 = reinterpret_cast< wxMenu * >(argp1);
43587 ecode2 = SWIG_AsVal_int(obj1, &val2);
43588 if (!SWIG_IsOK(ecode2)) {
43589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43590 }
43591 arg2 = static_cast< int >(val2);
43592 {
43593 PyThreadState* __tstate = wxPyBeginAllowThreads();
43594 result = (bool)(arg1)->Destroy(arg2);
43595 wxPyEndAllowThreads(__tstate);
43596 if (PyErr_Occurred()) SWIG_fail;
43597 }
43598 {
43599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43600 }
43601 return resultobj;
43602 fail:
43603 return NULL;
43604 }
43605
43606
43607 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43608 PyObject *resultobj = 0;
43609 wxMenu *arg1 = (wxMenu *) 0 ;
43610 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43611 bool result;
43612 void *argp1 = 0 ;
43613 int res1 = 0 ;
43614 void *argp2 = 0 ;
43615 int res2 = 0 ;
43616 PyObject * obj0 = 0 ;
43617 PyObject * obj1 = 0 ;
43618 char * kwnames[] = {
43619 (char *) "self",(char *) "item", NULL
43620 };
43621
43622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43624 if (!SWIG_IsOK(res1)) {
43625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43626 }
43627 arg1 = reinterpret_cast< wxMenu * >(argp1);
43628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43629 if (!SWIG_IsOK(res2)) {
43630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43631 }
43632 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43633 {
43634 PyThreadState* __tstate = wxPyBeginAllowThreads();
43635 result = (bool)(arg1)->Destroy(arg2);
43636 wxPyEndAllowThreads(__tstate);
43637 if (PyErr_Occurred()) SWIG_fail;
43638 }
43639 {
43640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43641 }
43642 return resultobj;
43643 fail:
43644 return NULL;
43645 }
43646
43647
43648 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43649 PyObject *resultobj = 0;
43650 wxMenu *arg1 = (wxMenu *) 0 ;
43651 size_t result;
43652 void *argp1 = 0 ;
43653 int res1 = 0 ;
43654 PyObject *swig_obj[1] ;
43655
43656 if (!args) SWIG_fail;
43657 swig_obj[0] = args;
43658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43659 if (!SWIG_IsOK(res1)) {
43660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43661 }
43662 arg1 = reinterpret_cast< wxMenu * >(argp1);
43663 {
43664 PyThreadState* __tstate = wxPyBeginAllowThreads();
43665 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43666 wxPyEndAllowThreads(__tstate);
43667 if (PyErr_Occurred()) SWIG_fail;
43668 }
43669 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43670 return resultobj;
43671 fail:
43672 return NULL;
43673 }
43674
43675
43676 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43677 PyObject *resultobj = 0;
43678 wxMenu *arg1 = (wxMenu *) 0 ;
43679 PyObject *result = 0 ;
43680 void *argp1 = 0 ;
43681 int res1 = 0 ;
43682 PyObject *swig_obj[1] ;
43683
43684 if (!args) SWIG_fail;
43685 swig_obj[0] = args;
43686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43687 if (!SWIG_IsOK(res1)) {
43688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43689 }
43690 arg1 = reinterpret_cast< wxMenu * >(argp1);
43691 {
43692 PyThreadState* __tstate = wxPyBeginAllowThreads();
43693 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43694 wxPyEndAllowThreads(__tstate);
43695 if (PyErr_Occurred()) SWIG_fail;
43696 }
43697 resultobj = result;
43698 return resultobj;
43699 fail:
43700 return NULL;
43701 }
43702
43703
43704 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43705 PyObject *resultobj = 0;
43706 wxMenu *arg1 = (wxMenu *) 0 ;
43707 wxString *arg2 = 0 ;
43708 int result;
43709 void *argp1 = 0 ;
43710 int res1 = 0 ;
43711 bool temp2 = false ;
43712 PyObject * obj0 = 0 ;
43713 PyObject * obj1 = 0 ;
43714 char * kwnames[] = {
43715 (char *) "self",(char *) "item", NULL
43716 };
43717
43718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43720 if (!SWIG_IsOK(res1)) {
43721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43722 }
43723 arg1 = reinterpret_cast< wxMenu * >(argp1);
43724 {
43725 arg2 = wxString_in_helper(obj1);
43726 if (arg2 == NULL) SWIG_fail;
43727 temp2 = true;
43728 }
43729 {
43730 PyThreadState* __tstate = wxPyBeginAllowThreads();
43731 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43732 wxPyEndAllowThreads(__tstate);
43733 if (PyErr_Occurred()) SWIG_fail;
43734 }
43735 resultobj = SWIG_From_int(static_cast< int >(result));
43736 {
43737 if (temp2)
43738 delete arg2;
43739 }
43740 return resultobj;
43741 fail:
43742 {
43743 if (temp2)
43744 delete arg2;
43745 }
43746 return NULL;
43747 }
43748
43749
43750 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43751 PyObject *resultobj = 0;
43752 wxMenu *arg1 = (wxMenu *) 0 ;
43753 int arg2 ;
43754 wxMenuItem *result = 0 ;
43755 void *argp1 = 0 ;
43756 int res1 = 0 ;
43757 int val2 ;
43758 int ecode2 = 0 ;
43759 PyObject * obj0 = 0 ;
43760 PyObject * obj1 = 0 ;
43761 char * kwnames[] = {
43762 (char *) "self",(char *) "id", NULL
43763 };
43764
43765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43767 if (!SWIG_IsOK(res1)) {
43768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43769 }
43770 arg1 = reinterpret_cast< wxMenu * >(argp1);
43771 ecode2 = SWIG_AsVal_int(obj1, &val2);
43772 if (!SWIG_IsOK(ecode2)) {
43773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43774 }
43775 arg2 = static_cast< int >(val2);
43776 {
43777 PyThreadState* __tstate = wxPyBeginAllowThreads();
43778 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43779 wxPyEndAllowThreads(__tstate);
43780 if (PyErr_Occurred()) SWIG_fail;
43781 }
43782 {
43783 resultobj = wxPyMake_wxObject(result, (bool)0);
43784 }
43785 return resultobj;
43786 fail:
43787 return NULL;
43788 }
43789
43790
43791 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43792 PyObject *resultobj = 0;
43793 wxMenu *arg1 = (wxMenu *) 0 ;
43794 size_t arg2 ;
43795 wxMenuItem *result = 0 ;
43796 void *argp1 = 0 ;
43797 int res1 = 0 ;
43798 size_t val2 ;
43799 int ecode2 = 0 ;
43800 PyObject * obj0 = 0 ;
43801 PyObject * obj1 = 0 ;
43802 char * kwnames[] = {
43803 (char *) "self",(char *) "position", NULL
43804 };
43805
43806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43808 if (!SWIG_IsOK(res1)) {
43809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43810 }
43811 arg1 = reinterpret_cast< wxMenu * >(argp1);
43812 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43813 if (!SWIG_IsOK(ecode2)) {
43814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43815 }
43816 arg2 = static_cast< size_t >(val2);
43817 {
43818 PyThreadState* __tstate = wxPyBeginAllowThreads();
43819 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43820 wxPyEndAllowThreads(__tstate);
43821 if (PyErr_Occurred()) SWIG_fail;
43822 }
43823 {
43824 resultobj = wxPyMake_wxObject(result, (bool)0);
43825 }
43826 return resultobj;
43827 fail:
43828 return NULL;
43829 }
43830
43831
43832 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43833 PyObject *resultobj = 0;
43834 wxMenu *arg1 = (wxMenu *) 0 ;
43835 int arg2 ;
43836 bool arg3 ;
43837 void *argp1 = 0 ;
43838 int res1 = 0 ;
43839 int val2 ;
43840 int ecode2 = 0 ;
43841 bool val3 ;
43842 int ecode3 = 0 ;
43843 PyObject * obj0 = 0 ;
43844 PyObject * obj1 = 0 ;
43845 PyObject * obj2 = 0 ;
43846 char * kwnames[] = {
43847 (char *) "self",(char *) "id",(char *) "enable", NULL
43848 };
43849
43850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43852 if (!SWIG_IsOK(res1)) {
43853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43854 }
43855 arg1 = reinterpret_cast< wxMenu * >(argp1);
43856 ecode2 = SWIG_AsVal_int(obj1, &val2);
43857 if (!SWIG_IsOK(ecode2)) {
43858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43859 }
43860 arg2 = static_cast< int >(val2);
43861 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43862 if (!SWIG_IsOK(ecode3)) {
43863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43864 }
43865 arg3 = static_cast< bool >(val3);
43866 {
43867 PyThreadState* __tstate = wxPyBeginAllowThreads();
43868 (arg1)->Enable(arg2,arg3);
43869 wxPyEndAllowThreads(__tstate);
43870 if (PyErr_Occurred()) SWIG_fail;
43871 }
43872 resultobj = SWIG_Py_Void();
43873 return resultobj;
43874 fail:
43875 return NULL;
43876 }
43877
43878
43879 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43880 PyObject *resultobj = 0;
43881 wxMenu *arg1 = (wxMenu *) 0 ;
43882 int arg2 ;
43883 bool result;
43884 void *argp1 = 0 ;
43885 int res1 = 0 ;
43886 int val2 ;
43887 int ecode2 = 0 ;
43888 PyObject * obj0 = 0 ;
43889 PyObject * obj1 = 0 ;
43890 char * kwnames[] = {
43891 (char *) "self",(char *) "id", NULL
43892 };
43893
43894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43896 if (!SWIG_IsOK(res1)) {
43897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43898 }
43899 arg1 = reinterpret_cast< wxMenu * >(argp1);
43900 ecode2 = SWIG_AsVal_int(obj1, &val2);
43901 if (!SWIG_IsOK(ecode2)) {
43902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43903 }
43904 arg2 = static_cast< int >(val2);
43905 {
43906 PyThreadState* __tstate = wxPyBeginAllowThreads();
43907 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43908 wxPyEndAllowThreads(__tstate);
43909 if (PyErr_Occurred()) SWIG_fail;
43910 }
43911 {
43912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43913 }
43914 return resultobj;
43915 fail:
43916 return NULL;
43917 }
43918
43919
43920 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43921 PyObject *resultobj = 0;
43922 wxMenu *arg1 = (wxMenu *) 0 ;
43923 int arg2 ;
43924 bool arg3 ;
43925 void *argp1 = 0 ;
43926 int res1 = 0 ;
43927 int val2 ;
43928 int ecode2 = 0 ;
43929 bool val3 ;
43930 int ecode3 = 0 ;
43931 PyObject * obj0 = 0 ;
43932 PyObject * obj1 = 0 ;
43933 PyObject * obj2 = 0 ;
43934 char * kwnames[] = {
43935 (char *) "self",(char *) "id",(char *) "check", NULL
43936 };
43937
43938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43940 if (!SWIG_IsOK(res1)) {
43941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43942 }
43943 arg1 = reinterpret_cast< wxMenu * >(argp1);
43944 ecode2 = SWIG_AsVal_int(obj1, &val2);
43945 if (!SWIG_IsOK(ecode2)) {
43946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43947 }
43948 arg2 = static_cast< int >(val2);
43949 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43950 if (!SWIG_IsOK(ecode3)) {
43951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43952 }
43953 arg3 = static_cast< bool >(val3);
43954 {
43955 PyThreadState* __tstate = wxPyBeginAllowThreads();
43956 (arg1)->Check(arg2,arg3);
43957 wxPyEndAllowThreads(__tstate);
43958 if (PyErr_Occurred()) SWIG_fail;
43959 }
43960 resultobj = SWIG_Py_Void();
43961 return resultobj;
43962 fail:
43963 return NULL;
43964 }
43965
43966
43967 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43968 PyObject *resultobj = 0;
43969 wxMenu *arg1 = (wxMenu *) 0 ;
43970 int arg2 ;
43971 bool result;
43972 void *argp1 = 0 ;
43973 int res1 = 0 ;
43974 int val2 ;
43975 int ecode2 = 0 ;
43976 PyObject * obj0 = 0 ;
43977 PyObject * obj1 = 0 ;
43978 char * kwnames[] = {
43979 (char *) "self",(char *) "id", NULL
43980 };
43981
43982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43984 if (!SWIG_IsOK(res1)) {
43985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43986 }
43987 arg1 = reinterpret_cast< wxMenu * >(argp1);
43988 ecode2 = SWIG_AsVal_int(obj1, &val2);
43989 if (!SWIG_IsOK(ecode2)) {
43990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43991 }
43992 arg2 = static_cast< int >(val2);
43993 {
43994 PyThreadState* __tstate = wxPyBeginAllowThreads();
43995 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43996 wxPyEndAllowThreads(__tstate);
43997 if (PyErr_Occurred()) SWIG_fail;
43998 }
43999 {
44000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44001 }
44002 return resultobj;
44003 fail:
44004 return NULL;
44005 }
44006
44007
44008 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44009 PyObject *resultobj = 0;
44010 wxMenu *arg1 = (wxMenu *) 0 ;
44011 int arg2 ;
44012 wxString *arg3 = 0 ;
44013 void *argp1 = 0 ;
44014 int res1 = 0 ;
44015 int val2 ;
44016 int ecode2 = 0 ;
44017 bool temp3 = false ;
44018 PyObject * obj0 = 0 ;
44019 PyObject * obj1 = 0 ;
44020 PyObject * obj2 = 0 ;
44021 char * kwnames[] = {
44022 (char *) "self",(char *) "id",(char *) "label", NULL
44023 };
44024
44025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44027 if (!SWIG_IsOK(res1)) {
44028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44029 }
44030 arg1 = reinterpret_cast< wxMenu * >(argp1);
44031 ecode2 = SWIG_AsVal_int(obj1, &val2);
44032 if (!SWIG_IsOK(ecode2)) {
44033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44034 }
44035 arg2 = static_cast< int >(val2);
44036 {
44037 arg3 = wxString_in_helper(obj2);
44038 if (arg3 == NULL) SWIG_fail;
44039 temp3 = true;
44040 }
44041 {
44042 PyThreadState* __tstate = wxPyBeginAllowThreads();
44043 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44044 wxPyEndAllowThreads(__tstate);
44045 if (PyErr_Occurred()) SWIG_fail;
44046 }
44047 resultobj = SWIG_Py_Void();
44048 {
44049 if (temp3)
44050 delete arg3;
44051 }
44052 return resultobj;
44053 fail:
44054 {
44055 if (temp3)
44056 delete arg3;
44057 }
44058 return NULL;
44059 }
44060
44061
44062 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44063 PyObject *resultobj = 0;
44064 wxMenu *arg1 = (wxMenu *) 0 ;
44065 int arg2 ;
44066 wxString result;
44067 void *argp1 = 0 ;
44068 int res1 = 0 ;
44069 int val2 ;
44070 int ecode2 = 0 ;
44071 PyObject * obj0 = 0 ;
44072 PyObject * obj1 = 0 ;
44073 char * kwnames[] = {
44074 (char *) "self",(char *) "id", NULL
44075 };
44076
44077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44079 if (!SWIG_IsOK(res1)) {
44080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44081 }
44082 arg1 = reinterpret_cast< wxMenu * >(argp1);
44083 ecode2 = SWIG_AsVal_int(obj1, &val2);
44084 if (!SWIG_IsOK(ecode2)) {
44085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44086 }
44087 arg2 = static_cast< int >(val2);
44088 {
44089 PyThreadState* __tstate = wxPyBeginAllowThreads();
44090 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44091 wxPyEndAllowThreads(__tstate);
44092 if (PyErr_Occurred()) SWIG_fail;
44093 }
44094 {
44095 #if wxUSE_UNICODE
44096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44097 #else
44098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44099 #endif
44100 }
44101 return resultobj;
44102 fail:
44103 return NULL;
44104 }
44105
44106
44107 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44108 PyObject *resultobj = 0;
44109 wxMenu *arg1 = (wxMenu *) 0 ;
44110 int arg2 ;
44111 wxString *arg3 = 0 ;
44112 void *argp1 = 0 ;
44113 int res1 = 0 ;
44114 int val2 ;
44115 int ecode2 = 0 ;
44116 bool temp3 = false ;
44117 PyObject * obj0 = 0 ;
44118 PyObject * obj1 = 0 ;
44119 PyObject * obj2 = 0 ;
44120 char * kwnames[] = {
44121 (char *) "self",(char *) "id",(char *) "helpString", NULL
44122 };
44123
44124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44126 if (!SWIG_IsOK(res1)) {
44127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44128 }
44129 arg1 = reinterpret_cast< wxMenu * >(argp1);
44130 ecode2 = SWIG_AsVal_int(obj1, &val2);
44131 if (!SWIG_IsOK(ecode2)) {
44132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44133 }
44134 arg2 = static_cast< int >(val2);
44135 {
44136 arg3 = wxString_in_helper(obj2);
44137 if (arg3 == NULL) SWIG_fail;
44138 temp3 = true;
44139 }
44140 {
44141 PyThreadState* __tstate = wxPyBeginAllowThreads();
44142 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44143 wxPyEndAllowThreads(__tstate);
44144 if (PyErr_Occurred()) SWIG_fail;
44145 }
44146 resultobj = SWIG_Py_Void();
44147 {
44148 if (temp3)
44149 delete arg3;
44150 }
44151 return resultobj;
44152 fail:
44153 {
44154 if (temp3)
44155 delete arg3;
44156 }
44157 return NULL;
44158 }
44159
44160
44161 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44162 PyObject *resultobj = 0;
44163 wxMenu *arg1 = (wxMenu *) 0 ;
44164 int arg2 ;
44165 wxString result;
44166 void *argp1 = 0 ;
44167 int res1 = 0 ;
44168 int val2 ;
44169 int ecode2 = 0 ;
44170 PyObject * obj0 = 0 ;
44171 PyObject * obj1 = 0 ;
44172 char * kwnames[] = {
44173 (char *) "self",(char *) "id", NULL
44174 };
44175
44176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44178 if (!SWIG_IsOK(res1)) {
44179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44180 }
44181 arg1 = reinterpret_cast< wxMenu * >(argp1);
44182 ecode2 = SWIG_AsVal_int(obj1, &val2);
44183 if (!SWIG_IsOK(ecode2)) {
44184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44185 }
44186 arg2 = static_cast< int >(val2);
44187 {
44188 PyThreadState* __tstate = wxPyBeginAllowThreads();
44189 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44190 wxPyEndAllowThreads(__tstate);
44191 if (PyErr_Occurred()) SWIG_fail;
44192 }
44193 {
44194 #if wxUSE_UNICODE
44195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44196 #else
44197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44198 #endif
44199 }
44200 return resultobj;
44201 fail:
44202 return NULL;
44203 }
44204
44205
44206 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44207 PyObject *resultobj = 0;
44208 wxMenu *arg1 = (wxMenu *) 0 ;
44209 wxString *arg2 = 0 ;
44210 void *argp1 = 0 ;
44211 int res1 = 0 ;
44212 bool temp2 = false ;
44213 PyObject * obj0 = 0 ;
44214 PyObject * obj1 = 0 ;
44215 char * kwnames[] = {
44216 (char *) "self",(char *) "title", NULL
44217 };
44218
44219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44221 if (!SWIG_IsOK(res1)) {
44222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44223 }
44224 arg1 = reinterpret_cast< wxMenu * >(argp1);
44225 {
44226 arg2 = wxString_in_helper(obj1);
44227 if (arg2 == NULL) SWIG_fail;
44228 temp2 = true;
44229 }
44230 {
44231 PyThreadState* __tstate = wxPyBeginAllowThreads();
44232 (arg1)->SetTitle((wxString const &)*arg2);
44233 wxPyEndAllowThreads(__tstate);
44234 if (PyErr_Occurred()) SWIG_fail;
44235 }
44236 resultobj = SWIG_Py_Void();
44237 {
44238 if (temp2)
44239 delete arg2;
44240 }
44241 return resultobj;
44242 fail:
44243 {
44244 if (temp2)
44245 delete arg2;
44246 }
44247 return NULL;
44248 }
44249
44250
44251 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44252 PyObject *resultobj = 0;
44253 wxMenu *arg1 = (wxMenu *) 0 ;
44254 wxString result;
44255 void *argp1 = 0 ;
44256 int res1 = 0 ;
44257 PyObject *swig_obj[1] ;
44258
44259 if (!args) SWIG_fail;
44260 swig_obj[0] = args;
44261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44262 if (!SWIG_IsOK(res1)) {
44263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44264 }
44265 arg1 = reinterpret_cast< wxMenu * >(argp1);
44266 {
44267 PyThreadState* __tstate = wxPyBeginAllowThreads();
44268 result = ((wxMenu const *)arg1)->GetTitle();
44269 wxPyEndAllowThreads(__tstate);
44270 if (PyErr_Occurred()) SWIG_fail;
44271 }
44272 {
44273 #if wxUSE_UNICODE
44274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44275 #else
44276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44277 #endif
44278 }
44279 return resultobj;
44280 fail:
44281 return NULL;
44282 }
44283
44284
44285 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44286 PyObject *resultobj = 0;
44287 wxMenu *arg1 = (wxMenu *) 0 ;
44288 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44289 void *argp1 = 0 ;
44290 int res1 = 0 ;
44291 void *argp2 = 0 ;
44292 int res2 = 0 ;
44293 PyObject * obj0 = 0 ;
44294 PyObject * obj1 = 0 ;
44295 char * kwnames[] = {
44296 (char *) "self",(char *) "handler", NULL
44297 };
44298
44299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44301 if (!SWIG_IsOK(res1)) {
44302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44303 }
44304 arg1 = reinterpret_cast< wxMenu * >(argp1);
44305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44306 if (!SWIG_IsOK(res2)) {
44307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44308 }
44309 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44310 {
44311 PyThreadState* __tstate = wxPyBeginAllowThreads();
44312 (arg1)->SetEventHandler(arg2);
44313 wxPyEndAllowThreads(__tstate);
44314 if (PyErr_Occurred()) SWIG_fail;
44315 }
44316 resultobj = SWIG_Py_Void();
44317 return resultobj;
44318 fail:
44319 return NULL;
44320 }
44321
44322
44323 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44324 PyObject *resultobj = 0;
44325 wxMenu *arg1 = (wxMenu *) 0 ;
44326 wxEvtHandler *result = 0 ;
44327 void *argp1 = 0 ;
44328 int res1 = 0 ;
44329 PyObject *swig_obj[1] ;
44330
44331 if (!args) SWIG_fail;
44332 swig_obj[0] = args;
44333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44334 if (!SWIG_IsOK(res1)) {
44335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44336 }
44337 arg1 = reinterpret_cast< wxMenu * >(argp1);
44338 {
44339 PyThreadState* __tstate = wxPyBeginAllowThreads();
44340 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44341 wxPyEndAllowThreads(__tstate);
44342 if (PyErr_Occurred()) SWIG_fail;
44343 }
44344 {
44345 resultobj = wxPyMake_wxObject(result, 0);
44346 }
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44354 PyObject *resultobj = 0;
44355 wxMenu *arg1 = (wxMenu *) 0 ;
44356 wxWindow *arg2 = (wxWindow *) 0 ;
44357 void *argp1 = 0 ;
44358 int res1 = 0 ;
44359 void *argp2 = 0 ;
44360 int res2 = 0 ;
44361 PyObject * obj0 = 0 ;
44362 PyObject * obj1 = 0 ;
44363 char * kwnames[] = {
44364 (char *) "self",(char *) "win", NULL
44365 };
44366
44367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44369 if (!SWIG_IsOK(res1)) {
44370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44371 }
44372 arg1 = reinterpret_cast< wxMenu * >(argp1);
44373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44374 if (!SWIG_IsOK(res2)) {
44375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44376 }
44377 arg2 = reinterpret_cast< wxWindow * >(argp2);
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 (arg1)->SetInvokingWindow(arg2);
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 resultobj = SWIG_Py_Void();
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44392 PyObject *resultobj = 0;
44393 wxMenu *arg1 = (wxMenu *) 0 ;
44394 wxWindow *result = 0 ;
44395 void *argp1 = 0 ;
44396 int res1 = 0 ;
44397 PyObject *swig_obj[1] ;
44398
44399 if (!args) SWIG_fail;
44400 swig_obj[0] = args;
44401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44402 if (!SWIG_IsOK(res1)) {
44403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44404 }
44405 arg1 = reinterpret_cast< wxMenu * >(argp1);
44406 {
44407 PyThreadState* __tstate = wxPyBeginAllowThreads();
44408 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 {
44413 resultobj = wxPyMake_wxObject(result, 0);
44414 }
44415 return resultobj;
44416 fail:
44417 return NULL;
44418 }
44419
44420
44421 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44422 PyObject *resultobj = 0;
44423 wxMenu *arg1 = (wxMenu *) 0 ;
44424 long result;
44425 void *argp1 = 0 ;
44426 int res1 = 0 ;
44427 PyObject *swig_obj[1] ;
44428
44429 if (!args) SWIG_fail;
44430 swig_obj[0] = args;
44431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44432 if (!SWIG_IsOK(res1)) {
44433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44434 }
44435 arg1 = reinterpret_cast< wxMenu * >(argp1);
44436 {
44437 PyThreadState* __tstate = wxPyBeginAllowThreads();
44438 result = (long)((wxMenu const *)arg1)->GetStyle();
44439 wxPyEndAllowThreads(__tstate);
44440 if (PyErr_Occurred()) SWIG_fail;
44441 }
44442 resultobj = SWIG_From_long(static_cast< long >(result));
44443 return resultobj;
44444 fail:
44445 return NULL;
44446 }
44447
44448
44449 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44450 PyObject *resultobj = 0;
44451 wxMenu *arg1 = (wxMenu *) 0 ;
44452 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44453 void *argp1 = 0 ;
44454 int res1 = 0 ;
44455 void *argp2 = 0 ;
44456 int res2 = 0 ;
44457 PyObject * obj0 = 0 ;
44458 PyObject * obj1 = 0 ;
44459 char * kwnames[] = {
44460 (char *) "self",(char *) "source", NULL
44461 };
44462
44463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44465 if (!SWIG_IsOK(res1)) {
44466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44467 }
44468 arg1 = reinterpret_cast< wxMenu * >(argp1);
44469 if (obj1) {
44470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44471 if (!SWIG_IsOK(res2)) {
44472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44473 }
44474 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44475 }
44476 {
44477 PyThreadState* __tstate = wxPyBeginAllowThreads();
44478 (arg1)->UpdateUI(arg2);
44479 wxPyEndAllowThreads(__tstate);
44480 if (PyErr_Occurred()) SWIG_fail;
44481 }
44482 resultobj = SWIG_Py_Void();
44483 return resultobj;
44484 fail:
44485 return NULL;
44486 }
44487
44488
44489 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44490 PyObject *resultobj = 0;
44491 wxMenu *arg1 = (wxMenu *) 0 ;
44492 wxMenuBar *result = 0 ;
44493 void *argp1 = 0 ;
44494 int res1 = 0 ;
44495 PyObject *swig_obj[1] ;
44496
44497 if (!args) SWIG_fail;
44498 swig_obj[0] = args;
44499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44500 if (!SWIG_IsOK(res1)) {
44501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44502 }
44503 arg1 = reinterpret_cast< wxMenu * >(argp1);
44504 {
44505 PyThreadState* __tstate = wxPyBeginAllowThreads();
44506 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 {
44511 resultobj = wxPyMake_wxObject(result, (bool)0);
44512 }
44513 return resultobj;
44514 fail:
44515 return NULL;
44516 }
44517
44518
44519 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44520 PyObject *resultobj = 0;
44521 wxMenu *arg1 = (wxMenu *) 0 ;
44522 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44523 void *argp1 = 0 ;
44524 int res1 = 0 ;
44525 void *argp2 = 0 ;
44526 int res2 = 0 ;
44527 PyObject * obj0 = 0 ;
44528 PyObject * obj1 = 0 ;
44529 char * kwnames[] = {
44530 (char *) "self",(char *) "menubar", NULL
44531 };
44532
44533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44535 if (!SWIG_IsOK(res1)) {
44536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44537 }
44538 arg1 = reinterpret_cast< wxMenu * >(argp1);
44539 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44540 if (!SWIG_IsOK(res2)) {
44541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44542 }
44543 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44544 {
44545 PyThreadState* __tstate = wxPyBeginAllowThreads();
44546 (arg1)->Attach(arg2);
44547 wxPyEndAllowThreads(__tstate);
44548 if (PyErr_Occurred()) SWIG_fail;
44549 }
44550 resultobj = SWIG_Py_Void();
44551 return resultobj;
44552 fail:
44553 return NULL;
44554 }
44555
44556
44557 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44558 PyObject *resultobj = 0;
44559 wxMenu *arg1 = (wxMenu *) 0 ;
44560 void *argp1 = 0 ;
44561 int res1 = 0 ;
44562 PyObject *swig_obj[1] ;
44563
44564 if (!args) SWIG_fail;
44565 swig_obj[0] = args;
44566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44567 if (!SWIG_IsOK(res1)) {
44568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44569 }
44570 arg1 = reinterpret_cast< wxMenu * >(argp1);
44571 {
44572 PyThreadState* __tstate = wxPyBeginAllowThreads();
44573 (arg1)->Detach();
44574 wxPyEndAllowThreads(__tstate);
44575 if (PyErr_Occurred()) SWIG_fail;
44576 }
44577 resultobj = SWIG_Py_Void();
44578 return resultobj;
44579 fail:
44580 return NULL;
44581 }
44582
44583
44584 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44585 PyObject *resultobj = 0;
44586 wxMenu *arg1 = (wxMenu *) 0 ;
44587 bool result;
44588 void *argp1 = 0 ;
44589 int res1 = 0 ;
44590 PyObject *swig_obj[1] ;
44591
44592 if (!args) SWIG_fail;
44593 swig_obj[0] = args;
44594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44595 if (!SWIG_IsOK(res1)) {
44596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44597 }
44598 arg1 = reinterpret_cast< wxMenu * >(argp1);
44599 {
44600 PyThreadState* __tstate = wxPyBeginAllowThreads();
44601 result = (bool)((wxMenu const *)arg1)->IsAttached();
44602 wxPyEndAllowThreads(__tstate);
44603 if (PyErr_Occurred()) SWIG_fail;
44604 }
44605 {
44606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44607 }
44608 return resultobj;
44609 fail:
44610 return NULL;
44611 }
44612
44613
44614 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44615 PyObject *resultobj = 0;
44616 wxMenu *arg1 = (wxMenu *) 0 ;
44617 wxMenu *arg2 = (wxMenu *) 0 ;
44618 void *argp1 = 0 ;
44619 int res1 = 0 ;
44620 void *argp2 = 0 ;
44621 int res2 = 0 ;
44622 PyObject * obj0 = 0 ;
44623 PyObject * obj1 = 0 ;
44624 char * kwnames[] = {
44625 (char *) "self",(char *) "parent", NULL
44626 };
44627
44628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44630 if (!SWIG_IsOK(res1)) {
44631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44632 }
44633 arg1 = reinterpret_cast< wxMenu * >(argp1);
44634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44635 if (!SWIG_IsOK(res2)) {
44636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44637 }
44638 arg2 = reinterpret_cast< wxMenu * >(argp2);
44639 {
44640 PyThreadState* __tstate = wxPyBeginAllowThreads();
44641 (arg1)->SetParent(arg2);
44642 wxPyEndAllowThreads(__tstate);
44643 if (PyErr_Occurred()) SWIG_fail;
44644 }
44645 resultobj = SWIG_Py_Void();
44646 return resultobj;
44647 fail:
44648 return NULL;
44649 }
44650
44651
44652 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44653 PyObject *resultobj = 0;
44654 wxMenu *arg1 = (wxMenu *) 0 ;
44655 wxMenu *result = 0 ;
44656 void *argp1 = 0 ;
44657 int res1 = 0 ;
44658 PyObject *swig_obj[1] ;
44659
44660 if (!args) SWIG_fail;
44661 swig_obj[0] = args;
44662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44663 if (!SWIG_IsOK(res1)) {
44664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44665 }
44666 arg1 = reinterpret_cast< wxMenu * >(argp1);
44667 {
44668 PyThreadState* __tstate = wxPyBeginAllowThreads();
44669 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44670 wxPyEndAllowThreads(__tstate);
44671 if (PyErr_Occurred()) SWIG_fail;
44672 }
44673 {
44674 resultobj = wxPyMake_wxObject(result, 0);
44675 }
44676 return resultobj;
44677 fail:
44678 return NULL;
44679 }
44680
44681
44682 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44683 PyObject *obj;
44684 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44685 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44686 return SWIG_Py_Void();
44687 }
44688
44689 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44690 return SWIG_Python_InitShadowInstance(args);
44691 }
44692
44693 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44694 PyObject *resultobj = 0;
44695 long arg1 = (long) 0 ;
44696 wxMenuBar *result = 0 ;
44697 long val1 ;
44698 int ecode1 = 0 ;
44699 PyObject * obj0 = 0 ;
44700 char * kwnames[] = {
44701 (char *) "style", NULL
44702 };
44703
44704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44705 if (obj0) {
44706 ecode1 = SWIG_AsVal_long(obj0, &val1);
44707 if (!SWIG_IsOK(ecode1)) {
44708 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44709 }
44710 arg1 = static_cast< long >(val1);
44711 }
44712 {
44713 if (!wxPyCheckForApp()) SWIG_fail;
44714 PyThreadState* __tstate = wxPyBeginAllowThreads();
44715 result = (wxMenuBar *)new wxMenuBar(arg1);
44716 wxPyEndAllowThreads(__tstate);
44717 if (PyErr_Occurred()) SWIG_fail;
44718 }
44719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44720 return resultobj;
44721 fail:
44722 return NULL;
44723 }
44724
44725
44726 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44727 PyObject *resultobj = 0;
44728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44729 wxMenu *arg2 = (wxMenu *) 0 ;
44730 wxString *arg3 = 0 ;
44731 bool result;
44732 void *argp1 = 0 ;
44733 int res1 = 0 ;
44734 void *argp2 = 0 ;
44735 int res2 = 0 ;
44736 bool temp3 = false ;
44737 PyObject * obj0 = 0 ;
44738 PyObject * obj1 = 0 ;
44739 PyObject * obj2 = 0 ;
44740 char * kwnames[] = {
44741 (char *) "self",(char *) "menu",(char *) "title", NULL
44742 };
44743
44744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44746 if (!SWIG_IsOK(res1)) {
44747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44748 }
44749 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44751 if (!SWIG_IsOK(res2)) {
44752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44753 }
44754 arg2 = reinterpret_cast< wxMenu * >(argp2);
44755 {
44756 arg3 = wxString_in_helper(obj2);
44757 if (arg3 == NULL) SWIG_fail;
44758 temp3 = true;
44759 }
44760 {
44761 PyThreadState* __tstate = wxPyBeginAllowThreads();
44762 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44763 wxPyEndAllowThreads(__tstate);
44764 if (PyErr_Occurred()) SWIG_fail;
44765 }
44766 {
44767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44768 }
44769 {
44770 if (temp3)
44771 delete arg3;
44772 }
44773 return resultobj;
44774 fail:
44775 {
44776 if (temp3)
44777 delete arg3;
44778 }
44779 return NULL;
44780 }
44781
44782
44783 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44784 PyObject *resultobj = 0;
44785 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44786 size_t arg2 ;
44787 wxMenu *arg3 = (wxMenu *) 0 ;
44788 wxString *arg4 = 0 ;
44789 bool result;
44790 void *argp1 = 0 ;
44791 int res1 = 0 ;
44792 size_t val2 ;
44793 int ecode2 = 0 ;
44794 void *argp3 = 0 ;
44795 int res3 = 0 ;
44796 bool temp4 = false ;
44797 PyObject * obj0 = 0 ;
44798 PyObject * obj1 = 0 ;
44799 PyObject * obj2 = 0 ;
44800 PyObject * obj3 = 0 ;
44801 char * kwnames[] = {
44802 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44803 };
44804
44805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44807 if (!SWIG_IsOK(res1)) {
44808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44809 }
44810 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44811 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44812 if (!SWIG_IsOK(ecode2)) {
44813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44814 }
44815 arg2 = static_cast< size_t >(val2);
44816 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44817 if (!SWIG_IsOK(res3)) {
44818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44819 }
44820 arg3 = reinterpret_cast< wxMenu * >(argp3);
44821 {
44822 arg4 = wxString_in_helper(obj3);
44823 if (arg4 == NULL) SWIG_fail;
44824 temp4 = true;
44825 }
44826 {
44827 PyThreadState* __tstate = wxPyBeginAllowThreads();
44828 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44829 wxPyEndAllowThreads(__tstate);
44830 if (PyErr_Occurred()) SWIG_fail;
44831 }
44832 {
44833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44834 }
44835 {
44836 if (temp4)
44837 delete arg4;
44838 }
44839 return resultobj;
44840 fail:
44841 {
44842 if (temp4)
44843 delete arg4;
44844 }
44845 return NULL;
44846 }
44847
44848
44849 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44850 PyObject *resultobj = 0;
44851 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44852 size_t result;
44853 void *argp1 = 0 ;
44854 int res1 = 0 ;
44855 PyObject *swig_obj[1] ;
44856
44857 if (!args) SWIG_fail;
44858 swig_obj[0] = args;
44859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44860 if (!SWIG_IsOK(res1)) {
44861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44862 }
44863 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44864 {
44865 PyThreadState* __tstate = wxPyBeginAllowThreads();
44866 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44867 wxPyEndAllowThreads(__tstate);
44868 if (PyErr_Occurred()) SWIG_fail;
44869 }
44870 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44871 return resultobj;
44872 fail:
44873 return NULL;
44874 }
44875
44876
44877 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44878 PyObject *resultobj = 0;
44879 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44880 size_t arg2 ;
44881 wxMenu *result = 0 ;
44882 void *argp1 = 0 ;
44883 int res1 = 0 ;
44884 size_t val2 ;
44885 int ecode2 = 0 ;
44886 PyObject * obj0 = 0 ;
44887 PyObject * obj1 = 0 ;
44888 char * kwnames[] = {
44889 (char *) "self",(char *) "pos", NULL
44890 };
44891
44892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44894 if (!SWIG_IsOK(res1)) {
44895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44896 }
44897 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44898 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44899 if (!SWIG_IsOK(ecode2)) {
44900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44901 }
44902 arg2 = static_cast< size_t >(val2);
44903 {
44904 PyThreadState* __tstate = wxPyBeginAllowThreads();
44905 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44906 wxPyEndAllowThreads(__tstate);
44907 if (PyErr_Occurred()) SWIG_fail;
44908 }
44909 {
44910 resultobj = wxPyMake_wxObject(result, 0);
44911 }
44912 return resultobj;
44913 fail:
44914 return NULL;
44915 }
44916
44917
44918 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44919 PyObject *resultobj = 0;
44920 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44921 size_t arg2 ;
44922 wxMenu *arg3 = (wxMenu *) 0 ;
44923 wxString *arg4 = 0 ;
44924 wxMenu *result = 0 ;
44925 void *argp1 = 0 ;
44926 int res1 = 0 ;
44927 size_t val2 ;
44928 int ecode2 = 0 ;
44929 void *argp3 = 0 ;
44930 int res3 = 0 ;
44931 bool temp4 = false ;
44932 PyObject * obj0 = 0 ;
44933 PyObject * obj1 = 0 ;
44934 PyObject * obj2 = 0 ;
44935 PyObject * obj3 = 0 ;
44936 char * kwnames[] = {
44937 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44938 };
44939
44940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44942 if (!SWIG_IsOK(res1)) {
44943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44944 }
44945 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44946 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44947 if (!SWIG_IsOK(ecode2)) {
44948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44949 }
44950 arg2 = static_cast< size_t >(val2);
44951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44952 if (!SWIG_IsOK(res3)) {
44953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44954 }
44955 arg3 = reinterpret_cast< wxMenu * >(argp3);
44956 {
44957 arg4 = wxString_in_helper(obj3);
44958 if (arg4 == NULL) SWIG_fail;
44959 temp4 = true;
44960 }
44961 {
44962 PyThreadState* __tstate = wxPyBeginAllowThreads();
44963 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44964 wxPyEndAllowThreads(__tstate);
44965 if (PyErr_Occurred()) SWIG_fail;
44966 }
44967 {
44968 resultobj = wxPyMake_wxObject(result, 0);
44969 }
44970 {
44971 if (temp4)
44972 delete arg4;
44973 }
44974 return resultobj;
44975 fail:
44976 {
44977 if (temp4)
44978 delete arg4;
44979 }
44980 return NULL;
44981 }
44982
44983
44984 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44985 PyObject *resultobj = 0;
44986 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44987 size_t arg2 ;
44988 wxMenu *result = 0 ;
44989 void *argp1 = 0 ;
44990 int res1 = 0 ;
44991 size_t val2 ;
44992 int ecode2 = 0 ;
44993 PyObject * obj0 = 0 ;
44994 PyObject * obj1 = 0 ;
44995 char * kwnames[] = {
44996 (char *) "self",(char *) "pos", NULL
44997 };
44998
44999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45001 if (!SWIG_IsOK(res1)) {
45002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45003 }
45004 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45005 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45006 if (!SWIG_IsOK(ecode2)) {
45007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45008 }
45009 arg2 = static_cast< size_t >(val2);
45010 {
45011 PyThreadState* __tstate = wxPyBeginAllowThreads();
45012 result = (wxMenu *)(arg1)->Remove(arg2);
45013 wxPyEndAllowThreads(__tstate);
45014 if (PyErr_Occurred()) SWIG_fail;
45015 }
45016 {
45017 resultobj = wxPyMake_wxObject(result, 0);
45018 }
45019 return resultobj;
45020 fail:
45021 return NULL;
45022 }
45023
45024
45025 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45026 PyObject *resultobj = 0;
45027 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45028 size_t arg2 ;
45029 bool arg3 ;
45030 void *argp1 = 0 ;
45031 int res1 = 0 ;
45032 size_t val2 ;
45033 int ecode2 = 0 ;
45034 bool val3 ;
45035 int ecode3 = 0 ;
45036 PyObject * obj0 = 0 ;
45037 PyObject * obj1 = 0 ;
45038 PyObject * obj2 = 0 ;
45039 char * kwnames[] = {
45040 (char *) "self",(char *) "pos",(char *) "enable", NULL
45041 };
45042
45043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45045 if (!SWIG_IsOK(res1)) {
45046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45047 }
45048 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45049 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45050 if (!SWIG_IsOK(ecode2)) {
45051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45052 }
45053 arg2 = static_cast< size_t >(val2);
45054 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45055 if (!SWIG_IsOK(ecode3)) {
45056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45057 }
45058 arg3 = static_cast< bool >(val3);
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 (arg1)->EnableTop(arg2,arg3);
45062 wxPyEndAllowThreads(__tstate);
45063 if (PyErr_Occurred()) SWIG_fail;
45064 }
45065 resultobj = SWIG_Py_Void();
45066 return resultobj;
45067 fail:
45068 return NULL;
45069 }
45070
45071
45072 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45073 PyObject *resultobj = 0;
45074 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45075 size_t arg2 ;
45076 bool result;
45077 void *argp1 = 0 ;
45078 int res1 = 0 ;
45079 size_t val2 ;
45080 int ecode2 = 0 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 char * kwnames[] = {
45084 (char *) "self",(char *) "pos", NULL
45085 };
45086
45087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45089 if (!SWIG_IsOK(res1)) {
45090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45091 }
45092 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45093 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45094 if (!SWIG_IsOK(ecode2)) {
45095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45096 }
45097 arg2 = static_cast< size_t >(val2);
45098 {
45099 PyThreadState* __tstate = wxPyBeginAllowThreads();
45100 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45101 wxPyEndAllowThreads(__tstate);
45102 if (PyErr_Occurred()) SWIG_fail;
45103 }
45104 {
45105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45106 }
45107 return resultobj;
45108 fail:
45109 return NULL;
45110 }
45111
45112
45113 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45114 PyObject *resultobj = 0;
45115 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45116 size_t arg2 ;
45117 wxString *arg3 = 0 ;
45118 void *argp1 = 0 ;
45119 int res1 = 0 ;
45120 size_t val2 ;
45121 int ecode2 = 0 ;
45122 bool temp3 = false ;
45123 PyObject * obj0 = 0 ;
45124 PyObject * obj1 = 0 ;
45125 PyObject * obj2 = 0 ;
45126 char * kwnames[] = {
45127 (char *) "self",(char *) "pos",(char *) "label", NULL
45128 };
45129
45130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45132 if (!SWIG_IsOK(res1)) {
45133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45134 }
45135 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45136 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45137 if (!SWIG_IsOK(ecode2)) {
45138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45139 }
45140 arg2 = static_cast< size_t >(val2);
45141 {
45142 arg3 = wxString_in_helper(obj2);
45143 if (arg3 == NULL) SWIG_fail;
45144 temp3 = true;
45145 }
45146 {
45147 PyThreadState* __tstate = wxPyBeginAllowThreads();
45148 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45149 wxPyEndAllowThreads(__tstate);
45150 if (PyErr_Occurred()) SWIG_fail;
45151 }
45152 resultobj = SWIG_Py_Void();
45153 {
45154 if (temp3)
45155 delete arg3;
45156 }
45157 return resultobj;
45158 fail:
45159 {
45160 if (temp3)
45161 delete arg3;
45162 }
45163 return NULL;
45164 }
45165
45166
45167 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45168 PyObject *resultobj = 0;
45169 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45170 size_t arg2 ;
45171 wxString result;
45172 void *argp1 = 0 ;
45173 int res1 = 0 ;
45174 size_t val2 ;
45175 int ecode2 = 0 ;
45176 PyObject * obj0 = 0 ;
45177 PyObject * obj1 = 0 ;
45178 char * kwnames[] = {
45179 (char *) "self",(char *) "pos", NULL
45180 };
45181
45182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45184 if (!SWIG_IsOK(res1)) {
45185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45186 }
45187 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45188 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45189 if (!SWIG_IsOK(ecode2)) {
45190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45191 }
45192 arg2 = static_cast< size_t >(val2);
45193 {
45194 PyThreadState* __tstate = wxPyBeginAllowThreads();
45195 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45196 wxPyEndAllowThreads(__tstate);
45197 if (PyErr_Occurred()) SWIG_fail;
45198 }
45199 {
45200 #if wxUSE_UNICODE
45201 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45202 #else
45203 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45204 #endif
45205 }
45206 return resultobj;
45207 fail:
45208 return NULL;
45209 }
45210
45211
45212 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45213 PyObject *resultobj = 0;
45214 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45215 wxString *arg2 = 0 ;
45216 wxString *arg3 = 0 ;
45217 int result;
45218 void *argp1 = 0 ;
45219 int res1 = 0 ;
45220 bool temp2 = false ;
45221 bool temp3 = false ;
45222 PyObject * obj0 = 0 ;
45223 PyObject * obj1 = 0 ;
45224 PyObject * obj2 = 0 ;
45225 char * kwnames[] = {
45226 (char *) "self",(char *) "menu",(char *) "item", NULL
45227 };
45228
45229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45231 if (!SWIG_IsOK(res1)) {
45232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45233 }
45234 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45235 {
45236 arg2 = wxString_in_helper(obj1);
45237 if (arg2 == NULL) SWIG_fail;
45238 temp2 = true;
45239 }
45240 {
45241 arg3 = wxString_in_helper(obj2);
45242 if (arg3 == NULL) SWIG_fail;
45243 temp3 = true;
45244 }
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45248 wxPyEndAllowThreads(__tstate);
45249 if (PyErr_Occurred()) SWIG_fail;
45250 }
45251 resultobj = SWIG_From_int(static_cast< int >(result));
45252 {
45253 if (temp2)
45254 delete arg2;
45255 }
45256 {
45257 if (temp3)
45258 delete arg3;
45259 }
45260 return resultobj;
45261 fail:
45262 {
45263 if (temp2)
45264 delete arg2;
45265 }
45266 {
45267 if (temp3)
45268 delete arg3;
45269 }
45270 return NULL;
45271 }
45272
45273
45274 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45275 PyObject *resultobj = 0;
45276 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45277 int arg2 ;
45278 wxMenuItem *result = 0 ;
45279 void *argp1 = 0 ;
45280 int res1 = 0 ;
45281 int val2 ;
45282 int ecode2 = 0 ;
45283 PyObject * obj0 = 0 ;
45284 PyObject * obj1 = 0 ;
45285 char * kwnames[] = {
45286 (char *) "self",(char *) "id", NULL
45287 };
45288
45289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45291 if (!SWIG_IsOK(res1)) {
45292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45293 }
45294 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45295 ecode2 = SWIG_AsVal_int(obj1, &val2);
45296 if (!SWIG_IsOK(ecode2)) {
45297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45298 }
45299 arg2 = static_cast< int >(val2);
45300 {
45301 PyThreadState* __tstate = wxPyBeginAllowThreads();
45302 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45303 wxPyEndAllowThreads(__tstate);
45304 if (PyErr_Occurred()) SWIG_fail;
45305 }
45306 {
45307 resultobj = wxPyMake_wxObject(result, (bool)0);
45308 }
45309 return resultobj;
45310 fail:
45311 return NULL;
45312 }
45313
45314
45315 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45316 PyObject *resultobj = 0;
45317 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45318 wxString *arg2 = 0 ;
45319 int result;
45320 void *argp1 = 0 ;
45321 int res1 = 0 ;
45322 bool temp2 = false ;
45323 PyObject * obj0 = 0 ;
45324 PyObject * obj1 = 0 ;
45325 char * kwnames[] = {
45326 (char *) "self",(char *) "title", NULL
45327 };
45328
45329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45331 if (!SWIG_IsOK(res1)) {
45332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45333 }
45334 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45335 {
45336 arg2 = wxString_in_helper(obj1);
45337 if (arg2 == NULL) SWIG_fail;
45338 temp2 = true;
45339 }
45340 {
45341 PyThreadState* __tstate = wxPyBeginAllowThreads();
45342 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45343 wxPyEndAllowThreads(__tstate);
45344 if (PyErr_Occurred()) SWIG_fail;
45345 }
45346 resultobj = SWIG_From_int(static_cast< int >(result));
45347 {
45348 if (temp2)
45349 delete arg2;
45350 }
45351 return resultobj;
45352 fail:
45353 {
45354 if (temp2)
45355 delete arg2;
45356 }
45357 return NULL;
45358 }
45359
45360
45361 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45362 PyObject *resultobj = 0;
45363 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45364 int arg2 ;
45365 bool arg3 ;
45366 void *argp1 = 0 ;
45367 int res1 = 0 ;
45368 int val2 ;
45369 int ecode2 = 0 ;
45370 bool val3 ;
45371 int ecode3 = 0 ;
45372 PyObject * obj0 = 0 ;
45373 PyObject * obj1 = 0 ;
45374 PyObject * obj2 = 0 ;
45375 char * kwnames[] = {
45376 (char *) "self",(char *) "id",(char *) "enable", NULL
45377 };
45378
45379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45381 if (!SWIG_IsOK(res1)) {
45382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45383 }
45384 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45385 ecode2 = SWIG_AsVal_int(obj1, &val2);
45386 if (!SWIG_IsOK(ecode2)) {
45387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45388 }
45389 arg2 = static_cast< int >(val2);
45390 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45391 if (!SWIG_IsOK(ecode3)) {
45392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45393 }
45394 arg3 = static_cast< bool >(val3);
45395 {
45396 PyThreadState* __tstate = wxPyBeginAllowThreads();
45397 (arg1)->Enable(arg2,arg3);
45398 wxPyEndAllowThreads(__tstate);
45399 if (PyErr_Occurred()) SWIG_fail;
45400 }
45401 resultobj = SWIG_Py_Void();
45402 return resultobj;
45403 fail:
45404 return NULL;
45405 }
45406
45407
45408 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45409 PyObject *resultobj = 0;
45410 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45411 int arg2 ;
45412 bool arg3 ;
45413 void *argp1 = 0 ;
45414 int res1 = 0 ;
45415 int val2 ;
45416 int ecode2 = 0 ;
45417 bool val3 ;
45418 int ecode3 = 0 ;
45419 PyObject * obj0 = 0 ;
45420 PyObject * obj1 = 0 ;
45421 PyObject * obj2 = 0 ;
45422 char * kwnames[] = {
45423 (char *) "self",(char *) "id",(char *) "check", NULL
45424 };
45425
45426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45428 if (!SWIG_IsOK(res1)) {
45429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45430 }
45431 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45432 ecode2 = SWIG_AsVal_int(obj1, &val2);
45433 if (!SWIG_IsOK(ecode2)) {
45434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45435 }
45436 arg2 = static_cast< int >(val2);
45437 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45438 if (!SWIG_IsOK(ecode3)) {
45439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45440 }
45441 arg3 = static_cast< bool >(val3);
45442 {
45443 PyThreadState* __tstate = wxPyBeginAllowThreads();
45444 (arg1)->Check(arg2,arg3);
45445 wxPyEndAllowThreads(__tstate);
45446 if (PyErr_Occurred()) SWIG_fail;
45447 }
45448 resultobj = SWIG_Py_Void();
45449 return resultobj;
45450 fail:
45451 return NULL;
45452 }
45453
45454
45455 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45456 PyObject *resultobj = 0;
45457 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45458 int arg2 ;
45459 bool result;
45460 void *argp1 = 0 ;
45461 int res1 = 0 ;
45462 int val2 ;
45463 int ecode2 = 0 ;
45464 PyObject * obj0 = 0 ;
45465 PyObject * obj1 = 0 ;
45466 char * kwnames[] = {
45467 (char *) "self",(char *) "id", NULL
45468 };
45469
45470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45472 if (!SWIG_IsOK(res1)) {
45473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45474 }
45475 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45476 ecode2 = SWIG_AsVal_int(obj1, &val2);
45477 if (!SWIG_IsOK(ecode2)) {
45478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45479 }
45480 arg2 = static_cast< int >(val2);
45481 {
45482 PyThreadState* __tstate = wxPyBeginAllowThreads();
45483 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45484 wxPyEndAllowThreads(__tstate);
45485 if (PyErr_Occurred()) SWIG_fail;
45486 }
45487 {
45488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45489 }
45490 return resultobj;
45491 fail:
45492 return NULL;
45493 }
45494
45495
45496 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45497 PyObject *resultobj = 0;
45498 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45499 int arg2 ;
45500 bool result;
45501 void *argp1 = 0 ;
45502 int res1 = 0 ;
45503 int val2 ;
45504 int ecode2 = 0 ;
45505 PyObject * obj0 = 0 ;
45506 PyObject * obj1 = 0 ;
45507 char * kwnames[] = {
45508 (char *) "self",(char *) "id", NULL
45509 };
45510
45511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45513 if (!SWIG_IsOK(res1)) {
45514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45515 }
45516 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45517 ecode2 = SWIG_AsVal_int(obj1, &val2);
45518 if (!SWIG_IsOK(ecode2)) {
45519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45520 }
45521 arg2 = static_cast< int >(val2);
45522 {
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45525 wxPyEndAllowThreads(__tstate);
45526 if (PyErr_Occurred()) SWIG_fail;
45527 }
45528 {
45529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45530 }
45531 return resultobj;
45532 fail:
45533 return NULL;
45534 }
45535
45536
45537 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45538 PyObject *resultobj = 0;
45539 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45540 int arg2 ;
45541 wxString *arg3 = 0 ;
45542 void *argp1 = 0 ;
45543 int res1 = 0 ;
45544 int val2 ;
45545 int ecode2 = 0 ;
45546 bool temp3 = false ;
45547 PyObject * obj0 = 0 ;
45548 PyObject * obj1 = 0 ;
45549 PyObject * obj2 = 0 ;
45550 char * kwnames[] = {
45551 (char *) "self",(char *) "id",(char *) "label", NULL
45552 };
45553
45554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45556 if (!SWIG_IsOK(res1)) {
45557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45558 }
45559 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45560 ecode2 = SWIG_AsVal_int(obj1, &val2);
45561 if (!SWIG_IsOK(ecode2)) {
45562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45563 }
45564 arg2 = static_cast< int >(val2);
45565 {
45566 arg3 = wxString_in_helper(obj2);
45567 if (arg3 == NULL) SWIG_fail;
45568 temp3 = true;
45569 }
45570 {
45571 PyThreadState* __tstate = wxPyBeginAllowThreads();
45572 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45573 wxPyEndAllowThreads(__tstate);
45574 if (PyErr_Occurred()) SWIG_fail;
45575 }
45576 resultobj = SWIG_Py_Void();
45577 {
45578 if (temp3)
45579 delete arg3;
45580 }
45581 return resultobj;
45582 fail:
45583 {
45584 if (temp3)
45585 delete arg3;
45586 }
45587 return NULL;
45588 }
45589
45590
45591 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45592 PyObject *resultobj = 0;
45593 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45594 int arg2 ;
45595 wxString result;
45596 void *argp1 = 0 ;
45597 int res1 = 0 ;
45598 int val2 ;
45599 int ecode2 = 0 ;
45600 PyObject * obj0 = 0 ;
45601 PyObject * obj1 = 0 ;
45602 char * kwnames[] = {
45603 (char *) "self",(char *) "id", NULL
45604 };
45605
45606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45608 if (!SWIG_IsOK(res1)) {
45609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45610 }
45611 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45612 ecode2 = SWIG_AsVal_int(obj1, &val2);
45613 if (!SWIG_IsOK(ecode2)) {
45614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45615 }
45616 arg2 = static_cast< int >(val2);
45617 {
45618 PyThreadState* __tstate = wxPyBeginAllowThreads();
45619 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45620 wxPyEndAllowThreads(__tstate);
45621 if (PyErr_Occurred()) SWIG_fail;
45622 }
45623 {
45624 #if wxUSE_UNICODE
45625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45626 #else
45627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45628 #endif
45629 }
45630 return resultobj;
45631 fail:
45632 return NULL;
45633 }
45634
45635
45636 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45637 PyObject *resultobj = 0;
45638 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45639 int arg2 ;
45640 wxString *arg3 = 0 ;
45641 void *argp1 = 0 ;
45642 int res1 = 0 ;
45643 int val2 ;
45644 int ecode2 = 0 ;
45645 bool temp3 = false ;
45646 PyObject * obj0 = 0 ;
45647 PyObject * obj1 = 0 ;
45648 PyObject * obj2 = 0 ;
45649 char * kwnames[] = {
45650 (char *) "self",(char *) "id",(char *) "helpString", NULL
45651 };
45652
45653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45655 if (!SWIG_IsOK(res1)) {
45656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45657 }
45658 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45659 ecode2 = SWIG_AsVal_int(obj1, &val2);
45660 if (!SWIG_IsOK(ecode2)) {
45661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45662 }
45663 arg2 = static_cast< int >(val2);
45664 {
45665 arg3 = wxString_in_helper(obj2);
45666 if (arg3 == NULL) SWIG_fail;
45667 temp3 = true;
45668 }
45669 {
45670 PyThreadState* __tstate = wxPyBeginAllowThreads();
45671 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45672 wxPyEndAllowThreads(__tstate);
45673 if (PyErr_Occurred()) SWIG_fail;
45674 }
45675 resultobj = SWIG_Py_Void();
45676 {
45677 if (temp3)
45678 delete arg3;
45679 }
45680 return resultobj;
45681 fail:
45682 {
45683 if (temp3)
45684 delete arg3;
45685 }
45686 return NULL;
45687 }
45688
45689
45690 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45691 PyObject *resultobj = 0;
45692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45693 int arg2 ;
45694 wxString result;
45695 void *argp1 = 0 ;
45696 int res1 = 0 ;
45697 int val2 ;
45698 int ecode2 = 0 ;
45699 PyObject * obj0 = 0 ;
45700 PyObject * obj1 = 0 ;
45701 char * kwnames[] = {
45702 (char *) "self",(char *) "id", NULL
45703 };
45704
45705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45707 if (!SWIG_IsOK(res1)) {
45708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45709 }
45710 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45711 ecode2 = SWIG_AsVal_int(obj1, &val2);
45712 if (!SWIG_IsOK(ecode2)) {
45713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45714 }
45715 arg2 = static_cast< int >(val2);
45716 {
45717 PyThreadState* __tstate = wxPyBeginAllowThreads();
45718 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45719 wxPyEndAllowThreads(__tstate);
45720 if (PyErr_Occurred()) SWIG_fail;
45721 }
45722 {
45723 #if wxUSE_UNICODE
45724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45725 #else
45726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45727 #endif
45728 }
45729 return resultobj;
45730 fail:
45731 return NULL;
45732 }
45733
45734
45735 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45736 PyObject *resultobj = 0;
45737 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45738 wxFrame *result = 0 ;
45739 void *argp1 = 0 ;
45740 int res1 = 0 ;
45741 PyObject *swig_obj[1] ;
45742
45743 if (!args) SWIG_fail;
45744 swig_obj[0] = args;
45745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45746 if (!SWIG_IsOK(res1)) {
45747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45748 }
45749 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45750 {
45751 PyThreadState* __tstate = wxPyBeginAllowThreads();
45752 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45753 wxPyEndAllowThreads(__tstate);
45754 if (PyErr_Occurred()) SWIG_fail;
45755 }
45756 {
45757 resultobj = wxPyMake_wxObject(result, (bool)0);
45758 }
45759 return resultobj;
45760 fail:
45761 return NULL;
45762 }
45763
45764
45765 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45766 PyObject *resultobj = 0;
45767 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45768 bool result;
45769 void *argp1 = 0 ;
45770 int res1 = 0 ;
45771 PyObject *swig_obj[1] ;
45772
45773 if (!args) SWIG_fail;
45774 swig_obj[0] = args;
45775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45776 if (!SWIG_IsOK(res1)) {
45777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45778 }
45779 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45780 {
45781 PyThreadState* __tstate = wxPyBeginAllowThreads();
45782 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45783 wxPyEndAllowThreads(__tstate);
45784 if (PyErr_Occurred()) SWIG_fail;
45785 }
45786 {
45787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45788 }
45789 return resultobj;
45790 fail:
45791 return NULL;
45792 }
45793
45794
45795 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45796 PyObject *resultobj = 0;
45797 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45798 wxFrame *arg2 = (wxFrame *) 0 ;
45799 void *argp1 = 0 ;
45800 int res1 = 0 ;
45801 void *argp2 = 0 ;
45802 int res2 = 0 ;
45803 PyObject * obj0 = 0 ;
45804 PyObject * obj1 = 0 ;
45805 char * kwnames[] = {
45806 (char *) "self",(char *) "frame", NULL
45807 };
45808
45809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45811 if (!SWIG_IsOK(res1)) {
45812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45813 }
45814 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45816 if (!SWIG_IsOK(res2)) {
45817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45818 }
45819 arg2 = reinterpret_cast< wxFrame * >(argp2);
45820 {
45821 PyThreadState* __tstate = wxPyBeginAllowThreads();
45822 (arg1)->Attach(arg2);
45823 wxPyEndAllowThreads(__tstate);
45824 if (PyErr_Occurred()) SWIG_fail;
45825 }
45826 resultobj = SWIG_Py_Void();
45827 return resultobj;
45828 fail:
45829 return NULL;
45830 }
45831
45832
45833 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45834 PyObject *resultobj = 0;
45835 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45836 void *argp1 = 0 ;
45837 int res1 = 0 ;
45838 PyObject *swig_obj[1] ;
45839
45840 if (!args) SWIG_fail;
45841 swig_obj[0] = args;
45842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45843 if (!SWIG_IsOK(res1)) {
45844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45845 }
45846 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45847 {
45848 PyThreadState* __tstate = wxPyBeginAllowThreads();
45849 (arg1)->Detach();
45850 wxPyEndAllowThreads(__tstate);
45851 if (PyErr_Occurred()) SWIG_fail;
45852 }
45853 resultobj = SWIG_Py_Void();
45854 return resultobj;
45855 fail:
45856 return NULL;
45857 }
45858
45859
45860 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45861 PyObject *resultobj = 0;
45862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 PyObject *swig_obj[1] ;
45866
45867 if (!args) SWIG_fail;
45868 swig_obj[0] = args;
45869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45870 if (!SWIG_IsOK(res1)) {
45871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45872 }
45873 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45874 {
45875 PyThreadState* __tstate = wxPyBeginAllowThreads();
45876 (arg1)->UpdateMenus();
45877 wxPyEndAllowThreads(__tstate);
45878 if (PyErr_Occurred()) SWIG_fail;
45879 }
45880 resultobj = SWIG_Py_Void();
45881 return resultobj;
45882 fail:
45883 return NULL;
45884 }
45885
45886
45887 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45888 PyObject *resultobj = 0;
45889 bool arg1 ;
45890 bool val1 ;
45891 int ecode1 = 0 ;
45892 PyObject * obj0 = 0 ;
45893 char * kwnames[] = {
45894 (char *) "enable", NULL
45895 };
45896
45897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45898 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45899 if (!SWIG_IsOK(ecode1)) {
45900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45901 }
45902 arg1 = static_cast< bool >(val1);
45903 {
45904 PyThreadState* __tstate = wxPyBeginAllowThreads();
45905 wxMenuBar_SetAutoWindowMenu(arg1);
45906 wxPyEndAllowThreads(__tstate);
45907 if (PyErr_Occurred()) SWIG_fail;
45908 }
45909 resultobj = SWIG_Py_Void();
45910 return resultobj;
45911 fail:
45912 return NULL;
45913 }
45914
45915
45916 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45917 PyObject *resultobj = 0;
45918 bool result;
45919
45920 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45921 {
45922 PyThreadState* __tstate = wxPyBeginAllowThreads();
45923 result = (bool)wxMenuBar_GetAutoWindowMenu();
45924 wxPyEndAllowThreads(__tstate);
45925 if (PyErr_Occurred()) SWIG_fail;
45926 }
45927 {
45928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45929 }
45930 return resultobj;
45931 fail:
45932 return NULL;
45933 }
45934
45935
45936 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45937 PyObject *obj;
45938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45939 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45940 return SWIG_Py_Void();
45941 }
45942
45943 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45944 return SWIG_Python_InitShadowInstance(args);
45945 }
45946
45947 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45948 PyObject *resultobj = 0;
45949 wxMenu *arg1 = (wxMenu *) NULL ;
45950 int arg2 = (int) wxID_SEPARATOR ;
45951 wxString const &arg3_defvalue = wxPyEmptyString ;
45952 wxString *arg3 = (wxString *) &arg3_defvalue ;
45953 wxString const &arg4_defvalue = wxPyEmptyString ;
45954 wxString *arg4 = (wxString *) &arg4_defvalue ;
45955 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45956 wxMenu *arg6 = (wxMenu *) NULL ;
45957 wxMenuItem *result = 0 ;
45958 void *argp1 = 0 ;
45959 int res1 = 0 ;
45960 int val2 ;
45961 int ecode2 = 0 ;
45962 bool temp3 = false ;
45963 bool temp4 = false ;
45964 int val5 ;
45965 int ecode5 = 0 ;
45966 void *argp6 = 0 ;
45967 int res6 = 0 ;
45968 PyObject * obj0 = 0 ;
45969 PyObject * obj1 = 0 ;
45970 PyObject * obj2 = 0 ;
45971 PyObject * obj3 = 0 ;
45972 PyObject * obj4 = 0 ;
45973 PyObject * obj5 = 0 ;
45974 char * kwnames[] = {
45975 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45976 };
45977
45978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45979 if (obj0) {
45980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45981 if (!SWIG_IsOK(res1)) {
45982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45983 }
45984 arg1 = reinterpret_cast< wxMenu * >(argp1);
45985 }
45986 if (obj1) {
45987 ecode2 = SWIG_AsVal_int(obj1, &val2);
45988 if (!SWIG_IsOK(ecode2)) {
45989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45990 }
45991 arg2 = static_cast< int >(val2);
45992 }
45993 if (obj2) {
45994 {
45995 arg3 = wxString_in_helper(obj2);
45996 if (arg3 == NULL) SWIG_fail;
45997 temp3 = true;
45998 }
45999 }
46000 if (obj3) {
46001 {
46002 arg4 = wxString_in_helper(obj3);
46003 if (arg4 == NULL) SWIG_fail;
46004 temp4 = true;
46005 }
46006 }
46007 if (obj4) {
46008 ecode5 = SWIG_AsVal_int(obj4, &val5);
46009 if (!SWIG_IsOK(ecode5)) {
46010 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46011 }
46012 arg5 = static_cast< wxItemKind >(val5);
46013 }
46014 if (obj5) {
46015 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46016 if (!SWIG_IsOK(res6)) {
46017 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46018 }
46019 arg6 = reinterpret_cast< wxMenu * >(argp6);
46020 }
46021 {
46022 PyThreadState* __tstate = wxPyBeginAllowThreads();
46023 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46024 wxPyEndAllowThreads(__tstate);
46025 if (PyErr_Occurred()) SWIG_fail;
46026 }
46027 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46028 {
46029 if (temp3)
46030 delete arg3;
46031 }
46032 {
46033 if (temp4)
46034 delete arg4;
46035 }
46036 return resultobj;
46037 fail:
46038 {
46039 if (temp3)
46040 delete arg3;
46041 }
46042 {
46043 if (temp4)
46044 delete arg4;
46045 }
46046 return NULL;
46047 }
46048
46049
46050 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46051 PyObject *resultobj = 0;
46052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46053 void *argp1 = 0 ;
46054 int res1 = 0 ;
46055 PyObject *swig_obj[1] ;
46056
46057 if (!args) SWIG_fail;
46058 swig_obj[0] = args;
46059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46060 if (!SWIG_IsOK(res1)) {
46061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46062 }
46063 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46064 {
46065 PyThreadState* __tstate = wxPyBeginAllowThreads();
46066 delete arg1;
46067
46068 wxPyEndAllowThreads(__tstate);
46069 if (PyErr_Occurred()) SWIG_fail;
46070 }
46071 resultobj = SWIG_Py_Void();
46072 return resultobj;
46073 fail:
46074 return NULL;
46075 }
46076
46077
46078 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46079 PyObject *resultobj = 0;
46080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46081 wxMenu *result = 0 ;
46082 void *argp1 = 0 ;
46083 int res1 = 0 ;
46084 PyObject *swig_obj[1] ;
46085
46086 if (!args) SWIG_fail;
46087 swig_obj[0] = args;
46088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46089 if (!SWIG_IsOK(res1)) {
46090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46091 }
46092 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46093 {
46094 PyThreadState* __tstate = wxPyBeginAllowThreads();
46095 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46096 wxPyEndAllowThreads(__tstate);
46097 if (PyErr_Occurred()) SWIG_fail;
46098 }
46099 {
46100 resultobj = wxPyMake_wxObject(result, 0);
46101 }
46102 return resultobj;
46103 fail:
46104 return NULL;
46105 }
46106
46107
46108 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46109 PyObject *resultobj = 0;
46110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46111 wxMenu *arg2 = (wxMenu *) 0 ;
46112 void *argp1 = 0 ;
46113 int res1 = 0 ;
46114 void *argp2 = 0 ;
46115 int res2 = 0 ;
46116 PyObject * obj0 = 0 ;
46117 PyObject * obj1 = 0 ;
46118 char * kwnames[] = {
46119 (char *) "self",(char *) "menu", NULL
46120 };
46121
46122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46124 if (!SWIG_IsOK(res1)) {
46125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46126 }
46127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46129 if (!SWIG_IsOK(res2)) {
46130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46131 }
46132 arg2 = reinterpret_cast< wxMenu * >(argp2);
46133 {
46134 PyThreadState* __tstate = wxPyBeginAllowThreads();
46135 (arg1)->SetMenu(arg2);
46136 wxPyEndAllowThreads(__tstate);
46137 if (PyErr_Occurred()) SWIG_fail;
46138 }
46139 resultobj = SWIG_Py_Void();
46140 return resultobj;
46141 fail:
46142 return NULL;
46143 }
46144
46145
46146 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46147 PyObject *resultobj = 0;
46148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46149 int arg2 ;
46150 void *argp1 = 0 ;
46151 int res1 = 0 ;
46152 int val2 ;
46153 int ecode2 = 0 ;
46154 PyObject * obj0 = 0 ;
46155 PyObject * obj1 = 0 ;
46156 char * kwnames[] = {
46157 (char *) "self",(char *) "id", NULL
46158 };
46159
46160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46162 if (!SWIG_IsOK(res1)) {
46163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46164 }
46165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46166 ecode2 = SWIG_AsVal_int(obj1, &val2);
46167 if (!SWIG_IsOK(ecode2)) {
46168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46169 }
46170 arg2 = static_cast< int >(val2);
46171 {
46172 PyThreadState* __tstate = wxPyBeginAllowThreads();
46173 (arg1)->SetId(arg2);
46174 wxPyEndAllowThreads(__tstate);
46175 if (PyErr_Occurred()) SWIG_fail;
46176 }
46177 resultobj = SWIG_Py_Void();
46178 return resultobj;
46179 fail:
46180 return NULL;
46181 }
46182
46183
46184 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46185 PyObject *resultobj = 0;
46186 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46187 int result;
46188 void *argp1 = 0 ;
46189 int res1 = 0 ;
46190 PyObject *swig_obj[1] ;
46191
46192 if (!args) SWIG_fail;
46193 swig_obj[0] = args;
46194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46195 if (!SWIG_IsOK(res1)) {
46196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46197 }
46198 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46199 {
46200 PyThreadState* __tstate = wxPyBeginAllowThreads();
46201 result = (int)((wxMenuItem const *)arg1)->GetId();
46202 wxPyEndAllowThreads(__tstate);
46203 if (PyErr_Occurred()) SWIG_fail;
46204 }
46205 resultobj = SWIG_From_int(static_cast< int >(result));
46206 return resultobj;
46207 fail:
46208 return NULL;
46209 }
46210
46211
46212 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46213 PyObject *resultobj = 0;
46214 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46215 bool result;
46216 void *argp1 = 0 ;
46217 int res1 = 0 ;
46218 PyObject *swig_obj[1] ;
46219
46220 if (!args) SWIG_fail;
46221 swig_obj[0] = args;
46222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46223 if (!SWIG_IsOK(res1)) {
46224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46225 }
46226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46227 {
46228 PyThreadState* __tstate = wxPyBeginAllowThreads();
46229 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46230 wxPyEndAllowThreads(__tstate);
46231 if (PyErr_Occurred()) SWIG_fail;
46232 }
46233 {
46234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46235 }
46236 return resultobj;
46237 fail:
46238 return NULL;
46239 }
46240
46241
46242 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46243 PyObject *resultobj = 0;
46244 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46245 wxString *arg2 = 0 ;
46246 void *argp1 = 0 ;
46247 int res1 = 0 ;
46248 bool temp2 = false ;
46249 PyObject * obj0 = 0 ;
46250 PyObject * obj1 = 0 ;
46251 char * kwnames[] = {
46252 (char *) "self",(char *) "str", NULL
46253 };
46254
46255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46257 if (!SWIG_IsOK(res1)) {
46258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46259 }
46260 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46261 {
46262 arg2 = wxString_in_helper(obj1);
46263 if (arg2 == NULL) SWIG_fail;
46264 temp2 = true;
46265 }
46266 {
46267 PyThreadState* __tstate = wxPyBeginAllowThreads();
46268 (arg1)->SetText((wxString const &)*arg2);
46269 wxPyEndAllowThreads(__tstate);
46270 if (PyErr_Occurred()) SWIG_fail;
46271 }
46272 resultobj = SWIG_Py_Void();
46273 {
46274 if (temp2)
46275 delete arg2;
46276 }
46277 return resultobj;
46278 fail:
46279 {
46280 if (temp2)
46281 delete arg2;
46282 }
46283 return NULL;
46284 }
46285
46286
46287 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46288 PyObject *resultobj = 0;
46289 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46290 wxString result;
46291 void *argp1 = 0 ;
46292 int res1 = 0 ;
46293 PyObject *swig_obj[1] ;
46294
46295 if (!args) SWIG_fail;
46296 swig_obj[0] = args;
46297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46298 if (!SWIG_IsOK(res1)) {
46299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46300 }
46301 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46302 {
46303 PyThreadState* __tstate = wxPyBeginAllowThreads();
46304 result = ((wxMenuItem const *)arg1)->GetLabel();
46305 wxPyEndAllowThreads(__tstate);
46306 if (PyErr_Occurred()) SWIG_fail;
46307 }
46308 {
46309 #if wxUSE_UNICODE
46310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46311 #else
46312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46313 #endif
46314 }
46315 return resultobj;
46316 fail:
46317 return NULL;
46318 }
46319
46320
46321 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46322 PyObject *resultobj = 0;
46323 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46324 wxString *result = 0 ;
46325 void *argp1 = 0 ;
46326 int res1 = 0 ;
46327 PyObject *swig_obj[1] ;
46328
46329 if (!args) SWIG_fail;
46330 swig_obj[0] = args;
46331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46332 if (!SWIG_IsOK(res1)) {
46333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46334 }
46335 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46336 {
46337 PyThreadState* __tstate = wxPyBeginAllowThreads();
46338 {
46339 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46340 result = (wxString *) &_result_ref;
46341 }
46342 wxPyEndAllowThreads(__tstate);
46343 if (PyErr_Occurred()) SWIG_fail;
46344 }
46345 {
46346 #if wxUSE_UNICODE
46347 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46348 #else
46349 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46350 #endif
46351 }
46352 return resultobj;
46353 fail:
46354 return NULL;
46355 }
46356
46357
46358 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46359 PyObject *resultobj = 0;
46360 wxString *arg1 = 0 ;
46361 wxString result;
46362 bool temp1 = false ;
46363 PyObject * obj0 = 0 ;
46364 char * kwnames[] = {
46365 (char *) "text", NULL
46366 };
46367
46368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46369 {
46370 arg1 = wxString_in_helper(obj0);
46371 if (arg1 == NULL) SWIG_fail;
46372 temp1 = true;
46373 }
46374 {
46375 PyThreadState* __tstate = wxPyBeginAllowThreads();
46376 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46377 wxPyEndAllowThreads(__tstate);
46378 if (PyErr_Occurred()) SWIG_fail;
46379 }
46380 {
46381 #if wxUSE_UNICODE
46382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46383 #else
46384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46385 #endif
46386 }
46387 {
46388 if (temp1)
46389 delete arg1;
46390 }
46391 return resultobj;
46392 fail:
46393 {
46394 if (temp1)
46395 delete arg1;
46396 }
46397 return NULL;
46398 }
46399
46400
46401 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46402 PyObject *resultobj = 0;
46403 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46404 wxItemKind result;
46405 void *argp1 = 0 ;
46406 int res1 = 0 ;
46407 PyObject *swig_obj[1] ;
46408
46409 if (!args) SWIG_fail;
46410 swig_obj[0] = args;
46411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46412 if (!SWIG_IsOK(res1)) {
46413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46414 }
46415 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46416 {
46417 PyThreadState* __tstate = wxPyBeginAllowThreads();
46418 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46419 wxPyEndAllowThreads(__tstate);
46420 if (PyErr_Occurred()) SWIG_fail;
46421 }
46422 resultobj = SWIG_From_int(static_cast< int >(result));
46423 return resultobj;
46424 fail:
46425 return NULL;
46426 }
46427
46428
46429 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46430 PyObject *resultobj = 0;
46431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46432 wxItemKind arg2 ;
46433 void *argp1 = 0 ;
46434 int res1 = 0 ;
46435 int val2 ;
46436 int ecode2 = 0 ;
46437 PyObject * obj0 = 0 ;
46438 PyObject * obj1 = 0 ;
46439 char * kwnames[] = {
46440 (char *) "self",(char *) "kind", NULL
46441 };
46442
46443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46445 if (!SWIG_IsOK(res1)) {
46446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46447 }
46448 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46449 ecode2 = SWIG_AsVal_int(obj1, &val2);
46450 if (!SWIG_IsOK(ecode2)) {
46451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46452 }
46453 arg2 = static_cast< wxItemKind >(val2);
46454 {
46455 PyThreadState* __tstate = wxPyBeginAllowThreads();
46456 (arg1)->SetKind(arg2);
46457 wxPyEndAllowThreads(__tstate);
46458 if (PyErr_Occurred()) SWIG_fail;
46459 }
46460 resultobj = SWIG_Py_Void();
46461 return resultobj;
46462 fail:
46463 return NULL;
46464 }
46465
46466
46467 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46468 PyObject *resultobj = 0;
46469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46470 bool arg2 ;
46471 void *argp1 = 0 ;
46472 int res1 = 0 ;
46473 bool val2 ;
46474 int ecode2 = 0 ;
46475 PyObject * obj0 = 0 ;
46476 PyObject * obj1 = 0 ;
46477 char * kwnames[] = {
46478 (char *) "self",(char *) "checkable", NULL
46479 };
46480
46481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46483 if (!SWIG_IsOK(res1)) {
46484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46485 }
46486 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46487 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46488 if (!SWIG_IsOK(ecode2)) {
46489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46490 }
46491 arg2 = static_cast< bool >(val2);
46492 {
46493 PyThreadState* __tstate = wxPyBeginAllowThreads();
46494 (arg1)->SetCheckable(arg2);
46495 wxPyEndAllowThreads(__tstate);
46496 if (PyErr_Occurred()) SWIG_fail;
46497 }
46498 resultobj = SWIG_Py_Void();
46499 return resultobj;
46500 fail:
46501 return NULL;
46502 }
46503
46504
46505 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46506 PyObject *resultobj = 0;
46507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46508 bool result;
46509 void *argp1 = 0 ;
46510 int res1 = 0 ;
46511 PyObject *swig_obj[1] ;
46512
46513 if (!args) SWIG_fail;
46514 swig_obj[0] = args;
46515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46516 if (!SWIG_IsOK(res1)) {
46517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46518 }
46519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46520 {
46521 PyThreadState* __tstate = wxPyBeginAllowThreads();
46522 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46523 wxPyEndAllowThreads(__tstate);
46524 if (PyErr_Occurred()) SWIG_fail;
46525 }
46526 {
46527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46528 }
46529 return resultobj;
46530 fail:
46531 return NULL;
46532 }
46533
46534
46535 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46536 PyObject *resultobj = 0;
46537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46538 bool result;
46539 void *argp1 = 0 ;
46540 int res1 = 0 ;
46541 PyObject *swig_obj[1] ;
46542
46543 if (!args) SWIG_fail;
46544 swig_obj[0] = args;
46545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46546 if (!SWIG_IsOK(res1)) {
46547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46548 }
46549 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46550 {
46551 PyThreadState* __tstate = wxPyBeginAllowThreads();
46552 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46553 wxPyEndAllowThreads(__tstate);
46554 if (PyErr_Occurred()) SWIG_fail;
46555 }
46556 {
46557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46558 }
46559 return resultobj;
46560 fail:
46561 return NULL;
46562 }
46563
46564
46565 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46566 PyObject *resultobj = 0;
46567 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46568 wxMenu *arg2 = (wxMenu *) 0 ;
46569 void *argp1 = 0 ;
46570 int res1 = 0 ;
46571 void *argp2 = 0 ;
46572 int res2 = 0 ;
46573 PyObject * obj0 = 0 ;
46574 PyObject * obj1 = 0 ;
46575 char * kwnames[] = {
46576 (char *) "self",(char *) "menu", NULL
46577 };
46578
46579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46581 if (!SWIG_IsOK(res1)) {
46582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46583 }
46584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46586 if (!SWIG_IsOK(res2)) {
46587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46588 }
46589 arg2 = reinterpret_cast< wxMenu * >(argp2);
46590 {
46591 PyThreadState* __tstate = wxPyBeginAllowThreads();
46592 (arg1)->SetSubMenu(arg2);
46593 wxPyEndAllowThreads(__tstate);
46594 if (PyErr_Occurred()) SWIG_fail;
46595 }
46596 resultobj = SWIG_Py_Void();
46597 return resultobj;
46598 fail:
46599 return NULL;
46600 }
46601
46602
46603 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46604 PyObject *resultobj = 0;
46605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46606 wxMenu *result = 0 ;
46607 void *argp1 = 0 ;
46608 int res1 = 0 ;
46609 PyObject *swig_obj[1] ;
46610
46611 if (!args) SWIG_fail;
46612 swig_obj[0] = args;
46613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46614 if (!SWIG_IsOK(res1)) {
46615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46616 }
46617 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46618 {
46619 PyThreadState* __tstate = wxPyBeginAllowThreads();
46620 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46621 wxPyEndAllowThreads(__tstate);
46622 if (PyErr_Occurred()) SWIG_fail;
46623 }
46624 {
46625 resultobj = wxPyMake_wxObject(result, 0);
46626 }
46627 return resultobj;
46628 fail:
46629 return NULL;
46630 }
46631
46632
46633 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46634 PyObject *resultobj = 0;
46635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46636 bool arg2 = (bool) true ;
46637 void *argp1 = 0 ;
46638 int res1 = 0 ;
46639 bool val2 ;
46640 int ecode2 = 0 ;
46641 PyObject * obj0 = 0 ;
46642 PyObject * obj1 = 0 ;
46643 char * kwnames[] = {
46644 (char *) "self",(char *) "enable", NULL
46645 };
46646
46647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46649 if (!SWIG_IsOK(res1)) {
46650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46651 }
46652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46653 if (obj1) {
46654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46655 if (!SWIG_IsOK(ecode2)) {
46656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46657 }
46658 arg2 = static_cast< bool >(val2);
46659 }
46660 {
46661 PyThreadState* __tstate = wxPyBeginAllowThreads();
46662 (arg1)->Enable(arg2);
46663 wxPyEndAllowThreads(__tstate);
46664 if (PyErr_Occurred()) SWIG_fail;
46665 }
46666 resultobj = SWIG_Py_Void();
46667 return resultobj;
46668 fail:
46669 return NULL;
46670 }
46671
46672
46673 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46674 PyObject *resultobj = 0;
46675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46676 bool result;
46677 void *argp1 = 0 ;
46678 int res1 = 0 ;
46679 PyObject *swig_obj[1] ;
46680
46681 if (!args) SWIG_fail;
46682 swig_obj[0] = args;
46683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46684 if (!SWIG_IsOK(res1)) {
46685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46686 }
46687 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46688 {
46689 PyThreadState* __tstate = wxPyBeginAllowThreads();
46690 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46691 wxPyEndAllowThreads(__tstate);
46692 if (PyErr_Occurred()) SWIG_fail;
46693 }
46694 {
46695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46696 }
46697 return resultobj;
46698 fail:
46699 return NULL;
46700 }
46701
46702
46703 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46704 PyObject *resultobj = 0;
46705 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46706 bool arg2 = (bool) true ;
46707 void *argp1 = 0 ;
46708 int res1 = 0 ;
46709 bool val2 ;
46710 int ecode2 = 0 ;
46711 PyObject * obj0 = 0 ;
46712 PyObject * obj1 = 0 ;
46713 char * kwnames[] = {
46714 (char *) "self",(char *) "check", NULL
46715 };
46716
46717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46719 if (!SWIG_IsOK(res1)) {
46720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46721 }
46722 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46723 if (obj1) {
46724 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46725 if (!SWIG_IsOK(ecode2)) {
46726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46727 }
46728 arg2 = static_cast< bool >(val2);
46729 }
46730 {
46731 PyThreadState* __tstate = wxPyBeginAllowThreads();
46732 (arg1)->Check(arg2);
46733 wxPyEndAllowThreads(__tstate);
46734 if (PyErr_Occurred()) SWIG_fail;
46735 }
46736 resultobj = SWIG_Py_Void();
46737 return resultobj;
46738 fail:
46739 return NULL;
46740 }
46741
46742
46743 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46744 PyObject *resultobj = 0;
46745 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46746 bool result;
46747 void *argp1 = 0 ;
46748 int res1 = 0 ;
46749 PyObject *swig_obj[1] ;
46750
46751 if (!args) SWIG_fail;
46752 swig_obj[0] = args;
46753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46754 if (!SWIG_IsOK(res1)) {
46755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46756 }
46757 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46758 {
46759 PyThreadState* __tstate = wxPyBeginAllowThreads();
46760 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46761 wxPyEndAllowThreads(__tstate);
46762 if (PyErr_Occurred()) SWIG_fail;
46763 }
46764 {
46765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46766 }
46767 return resultobj;
46768 fail:
46769 return NULL;
46770 }
46771
46772
46773 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46774 PyObject *resultobj = 0;
46775 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46776 void *argp1 = 0 ;
46777 int res1 = 0 ;
46778 PyObject *swig_obj[1] ;
46779
46780 if (!args) SWIG_fail;
46781 swig_obj[0] = args;
46782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46783 if (!SWIG_IsOK(res1)) {
46784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46785 }
46786 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46787 {
46788 PyThreadState* __tstate = wxPyBeginAllowThreads();
46789 (arg1)->Toggle();
46790 wxPyEndAllowThreads(__tstate);
46791 if (PyErr_Occurred()) SWIG_fail;
46792 }
46793 resultobj = SWIG_Py_Void();
46794 return resultobj;
46795 fail:
46796 return NULL;
46797 }
46798
46799
46800 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46801 PyObject *resultobj = 0;
46802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46803 wxString *arg2 = 0 ;
46804 void *argp1 = 0 ;
46805 int res1 = 0 ;
46806 bool temp2 = false ;
46807 PyObject * obj0 = 0 ;
46808 PyObject * obj1 = 0 ;
46809 char * kwnames[] = {
46810 (char *) "self",(char *) "str", NULL
46811 };
46812
46813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46815 if (!SWIG_IsOK(res1)) {
46816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46817 }
46818 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46819 {
46820 arg2 = wxString_in_helper(obj1);
46821 if (arg2 == NULL) SWIG_fail;
46822 temp2 = true;
46823 }
46824 {
46825 PyThreadState* __tstate = wxPyBeginAllowThreads();
46826 (arg1)->SetHelp((wxString const &)*arg2);
46827 wxPyEndAllowThreads(__tstate);
46828 if (PyErr_Occurred()) SWIG_fail;
46829 }
46830 resultobj = SWIG_Py_Void();
46831 {
46832 if (temp2)
46833 delete arg2;
46834 }
46835 return resultobj;
46836 fail:
46837 {
46838 if (temp2)
46839 delete arg2;
46840 }
46841 return NULL;
46842 }
46843
46844
46845 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46846 PyObject *resultobj = 0;
46847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46848 wxString *result = 0 ;
46849 void *argp1 = 0 ;
46850 int res1 = 0 ;
46851 PyObject *swig_obj[1] ;
46852
46853 if (!args) SWIG_fail;
46854 swig_obj[0] = args;
46855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46856 if (!SWIG_IsOK(res1)) {
46857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46858 }
46859 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46860 {
46861 PyThreadState* __tstate = wxPyBeginAllowThreads();
46862 {
46863 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46864 result = (wxString *) &_result_ref;
46865 }
46866 wxPyEndAllowThreads(__tstate);
46867 if (PyErr_Occurred()) SWIG_fail;
46868 }
46869 {
46870 #if wxUSE_UNICODE
46871 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46872 #else
46873 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46874 #endif
46875 }
46876 return resultobj;
46877 fail:
46878 return NULL;
46879 }
46880
46881
46882 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46883 PyObject *resultobj = 0;
46884 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46885 wxAcceleratorEntry *result = 0 ;
46886 void *argp1 = 0 ;
46887 int res1 = 0 ;
46888 PyObject *swig_obj[1] ;
46889
46890 if (!args) SWIG_fail;
46891 swig_obj[0] = args;
46892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46893 if (!SWIG_IsOK(res1)) {
46894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46895 }
46896 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46897 {
46898 PyThreadState* __tstate = wxPyBeginAllowThreads();
46899 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46900 wxPyEndAllowThreads(__tstate);
46901 if (PyErr_Occurred()) SWIG_fail;
46902 }
46903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46904 return resultobj;
46905 fail:
46906 return NULL;
46907 }
46908
46909
46910 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46911 PyObject *resultobj = 0;
46912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46913 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46914 void *argp1 = 0 ;
46915 int res1 = 0 ;
46916 void *argp2 = 0 ;
46917 int res2 = 0 ;
46918 PyObject * obj0 = 0 ;
46919 PyObject * obj1 = 0 ;
46920 char * kwnames[] = {
46921 (char *) "self",(char *) "accel", NULL
46922 };
46923
46924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46926 if (!SWIG_IsOK(res1)) {
46927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46928 }
46929 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46931 if (!SWIG_IsOK(res2)) {
46932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46933 }
46934 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46935 {
46936 PyThreadState* __tstate = wxPyBeginAllowThreads();
46937 (arg1)->SetAccel(arg2);
46938 wxPyEndAllowThreads(__tstate);
46939 if (PyErr_Occurred()) SWIG_fail;
46940 }
46941 resultobj = SWIG_Py_Void();
46942 return resultobj;
46943 fail:
46944 return NULL;
46945 }
46946
46947
46948 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46949 PyObject *resultobj = 0;
46950 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46951 wxBitmap *arg2 = 0 ;
46952 void *argp1 = 0 ;
46953 int res1 = 0 ;
46954 void *argp2 = 0 ;
46955 int res2 = 0 ;
46956 PyObject * obj0 = 0 ;
46957 PyObject * obj1 = 0 ;
46958 char * kwnames[] = {
46959 (char *) "self",(char *) "bitmap", NULL
46960 };
46961
46962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46964 if (!SWIG_IsOK(res1)) {
46965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46966 }
46967 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46969 if (!SWIG_IsOK(res2)) {
46970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46971 }
46972 if (!argp2) {
46973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46974 }
46975 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46976 {
46977 PyThreadState* __tstate = wxPyBeginAllowThreads();
46978 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46979 wxPyEndAllowThreads(__tstate);
46980 if (PyErr_Occurred()) SWIG_fail;
46981 }
46982 resultobj = SWIG_Py_Void();
46983 return resultobj;
46984 fail:
46985 return NULL;
46986 }
46987
46988
46989 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46990 PyObject *resultobj = 0;
46991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46992 wxBitmap *result = 0 ;
46993 void *argp1 = 0 ;
46994 int res1 = 0 ;
46995 PyObject *swig_obj[1] ;
46996
46997 if (!args) SWIG_fail;
46998 swig_obj[0] = args;
46999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47000 if (!SWIG_IsOK(res1)) {
47001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47002 }
47003 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47004 {
47005 PyThreadState* __tstate = wxPyBeginAllowThreads();
47006 {
47007 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47008 result = (wxBitmap *) &_result_ref;
47009 }
47010 wxPyEndAllowThreads(__tstate);
47011 if (PyErr_Occurred()) SWIG_fail;
47012 }
47013 {
47014 wxBitmap* resultptr = new wxBitmap(*result);
47015 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47016 }
47017 return resultobj;
47018 fail:
47019 return NULL;
47020 }
47021
47022
47023 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47024 PyObject *resultobj = 0;
47025 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47026 wxFont *arg2 = 0 ;
47027 void *argp1 = 0 ;
47028 int res1 = 0 ;
47029 void *argp2 = 0 ;
47030 int res2 = 0 ;
47031 PyObject * obj0 = 0 ;
47032 PyObject * obj1 = 0 ;
47033 char * kwnames[] = {
47034 (char *) "self",(char *) "font", NULL
47035 };
47036
47037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47039 if (!SWIG_IsOK(res1)) {
47040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47041 }
47042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47044 if (!SWIG_IsOK(res2)) {
47045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47046 }
47047 if (!argp2) {
47048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47049 }
47050 arg2 = reinterpret_cast< wxFont * >(argp2);
47051 {
47052 PyThreadState* __tstate = wxPyBeginAllowThreads();
47053 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 resultobj = SWIG_Py_Void();
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47065 PyObject *resultobj = 0;
47066 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47067 wxFont result;
47068 void *argp1 = 0 ;
47069 int res1 = 0 ;
47070 PyObject *swig_obj[1] ;
47071
47072 if (!args) SWIG_fail;
47073 swig_obj[0] = args;
47074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47075 if (!SWIG_IsOK(res1)) {
47076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47077 }
47078 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47079 {
47080 PyThreadState* __tstate = wxPyBeginAllowThreads();
47081 result = wxMenuItem_GetFont(arg1);
47082 wxPyEndAllowThreads(__tstate);
47083 if (PyErr_Occurred()) SWIG_fail;
47084 }
47085 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47086 return resultobj;
47087 fail:
47088 return NULL;
47089 }
47090
47091
47092 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47093 PyObject *resultobj = 0;
47094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47095 wxColour *arg2 = 0 ;
47096 void *argp1 = 0 ;
47097 int res1 = 0 ;
47098 wxColour temp2 ;
47099 PyObject * obj0 = 0 ;
47100 PyObject * obj1 = 0 ;
47101 char * kwnames[] = {
47102 (char *) "self",(char *) "colText", NULL
47103 };
47104
47105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47107 if (!SWIG_IsOK(res1)) {
47108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47109 }
47110 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47111 {
47112 arg2 = &temp2;
47113 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47114 }
47115 {
47116 PyThreadState* __tstate = wxPyBeginAllowThreads();
47117 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47118 wxPyEndAllowThreads(__tstate);
47119 if (PyErr_Occurred()) SWIG_fail;
47120 }
47121 resultobj = SWIG_Py_Void();
47122 return resultobj;
47123 fail:
47124 return NULL;
47125 }
47126
47127
47128 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47129 PyObject *resultobj = 0;
47130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47131 wxColour result;
47132 void *argp1 = 0 ;
47133 int res1 = 0 ;
47134 PyObject *swig_obj[1] ;
47135
47136 if (!args) SWIG_fail;
47137 swig_obj[0] = args;
47138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47139 if (!SWIG_IsOK(res1)) {
47140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47141 }
47142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47143 {
47144 PyThreadState* __tstate = wxPyBeginAllowThreads();
47145 result = wxMenuItem_GetTextColour(arg1);
47146 wxPyEndAllowThreads(__tstate);
47147 if (PyErr_Occurred()) SWIG_fail;
47148 }
47149 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47150 return resultobj;
47151 fail:
47152 return NULL;
47153 }
47154
47155
47156 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47157 PyObject *resultobj = 0;
47158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47159 wxColour *arg2 = 0 ;
47160 void *argp1 = 0 ;
47161 int res1 = 0 ;
47162 wxColour temp2 ;
47163 PyObject * obj0 = 0 ;
47164 PyObject * obj1 = 0 ;
47165 char * kwnames[] = {
47166 (char *) "self",(char *) "colBack", NULL
47167 };
47168
47169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47171 if (!SWIG_IsOK(res1)) {
47172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47173 }
47174 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47175 {
47176 arg2 = &temp2;
47177 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47178 }
47179 {
47180 PyThreadState* __tstate = wxPyBeginAllowThreads();
47181 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47182 wxPyEndAllowThreads(__tstate);
47183 if (PyErr_Occurred()) SWIG_fail;
47184 }
47185 resultobj = SWIG_Py_Void();
47186 return resultobj;
47187 fail:
47188 return NULL;
47189 }
47190
47191
47192 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47193 PyObject *resultobj = 0;
47194 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47195 wxColour result;
47196 void *argp1 = 0 ;
47197 int res1 = 0 ;
47198 PyObject *swig_obj[1] ;
47199
47200 if (!args) SWIG_fail;
47201 swig_obj[0] = args;
47202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47203 if (!SWIG_IsOK(res1)) {
47204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47205 }
47206 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47207 {
47208 PyThreadState* __tstate = wxPyBeginAllowThreads();
47209 result = wxMenuItem_GetBackgroundColour(arg1);
47210 wxPyEndAllowThreads(__tstate);
47211 if (PyErr_Occurred()) SWIG_fail;
47212 }
47213 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47214 return resultobj;
47215 fail:
47216 return NULL;
47217 }
47218
47219
47220 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47221 PyObject *resultobj = 0;
47222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47223 wxBitmap *arg2 = 0 ;
47224 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47225 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47226 void *argp1 = 0 ;
47227 int res1 = 0 ;
47228 void *argp2 = 0 ;
47229 int res2 = 0 ;
47230 void *argp3 = 0 ;
47231 int res3 = 0 ;
47232 PyObject * obj0 = 0 ;
47233 PyObject * obj1 = 0 ;
47234 PyObject * obj2 = 0 ;
47235 char * kwnames[] = {
47236 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47237 };
47238
47239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47241 if (!SWIG_IsOK(res1)) {
47242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47243 }
47244 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47246 if (!SWIG_IsOK(res2)) {
47247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47248 }
47249 if (!argp2) {
47250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47251 }
47252 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47253 if (obj2) {
47254 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47255 if (!SWIG_IsOK(res3)) {
47256 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47257 }
47258 if (!argp3) {
47259 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47260 }
47261 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47262 }
47263 {
47264 PyThreadState* __tstate = wxPyBeginAllowThreads();
47265 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47266 wxPyEndAllowThreads(__tstate);
47267 if (PyErr_Occurred()) SWIG_fail;
47268 }
47269 resultobj = SWIG_Py_Void();
47270 return resultobj;
47271 fail:
47272 return NULL;
47273 }
47274
47275
47276 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47277 PyObject *resultobj = 0;
47278 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47279 wxBitmap *arg2 = 0 ;
47280 void *argp1 = 0 ;
47281 int res1 = 0 ;
47282 void *argp2 = 0 ;
47283 int res2 = 0 ;
47284 PyObject * obj0 = 0 ;
47285 PyObject * obj1 = 0 ;
47286 char * kwnames[] = {
47287 (char *) "self",(char *) "bmpDisabled", NULL
47288 };
47289
47290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47292 if (!SWIG_IsOK(res1)) {
47293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47294 }
47295 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47296 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47297 if (!SWIG_IsOK(res2)) {
47298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47299 }
47300 if (!argp2) {
47301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47302 }
47303 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47304 {
47305 PyThreadState* __tstate = wxPyBeginAllowThreads();
47306 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47307 wxPyEndAllowThreads(__tstate);
47308 if (PyErr_Occurred()) SWIG_fail;
47309 }
47310 resultobj = SWIG_Py_Void();
47311 return resultobj;
47312 fail:
47313 return NULL;
47314 }
47315
47316
47317 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47318 PyObject *resultobj = 0;
47319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47320 wxBitmap *result = 0 ;
47321 void *argp1 = 0 ;
47322 int res1 = 0 ;
47323 PyObject *swig_obj[1] ;
47324
47325 if (!args) SWIG_fail;
47326 swig_obj[0] = args;
47327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47328 if (!SWIG_IsOK(res1)) {
47329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47330 }
47331 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47332 {
47333 PyThreadState* __tstate = wxPyBeginAllowThreads();
47334 {
47335 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47336 result = (wxBitmap *) &_result_ref;
47337 }
47338 wxPyEndAllowThreads(__tstate);
47339 if (PyErr_Occurred()) SWIG_fail;
47340 }
47341 {
47342 wxBitmap* resultptr = new wxBitmap(*result);
47343 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47344 }
47345 return resultobj;
47346 fail:
47347 return NULL;
47348 }
47349
47350
47351 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47352 PyObject *resultobj = 0;
47353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47354 int arg2 ;
47355 void *argp1 = 0 ;
47356 int res1 = 0 ;
47357 int val2 ;
47358 int ecode2 = 0 ;
47359 PyObject * obj0 = 0 ;
47360 PyObject * obj1 = 0 ;
47361 char * kwnames[] = {
47362 (char *) "self",(char *) "nWidth", NULL
47363 };
47364
47365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47367 if (!SWIG_IsOK(res1)) {
47368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47369 }
47370 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47371 ecode2 = SWIG_AsVal_int(obj1, &val2);
47372 if (!SWIG_IsOK(ecode2)) {
47373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47374 }
47375 arg2 = static_cast< int >(val2);
47376 {
47377 PyThreadState* __tstate = wxPyBeginAllowThreads();
47378 wxMenuItem_SetMarginWidth(arg1,arg2);
47379 wxPyEndAllowThreads(__tstate);
47380 if (PyErr_Occurred()) SWIG_fail;
47381 }
47382 resultobj = SWIG_Py_Void();
47383 return resultobj;
47384 fail:
47385 return NULL;
47386 }
47387
47388
47389 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47390 PyObject *resultobj = 0;
47391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47392 int result;
47393 void *argp1 = 0 ;
47394 int res1 = 0 ;
47395 PyObject *swig_obj[1] ;
47396
47397 if (!args) SWIG_fail;
47398 swig_obj[0] = args;
47399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47400 if (!SWIG_IsOK(res1)) {
47401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47402 }
47403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47404 {
47405 PyThreadState* __tstate = wxPyBeginAllowThreads();
47406 result = (int)wxMenuItem_GetMarginWidth(arg1);
47407 wxPyEndAllowThreads(__tstate);
47408 if (PyErr_Occurred()) SWIG_fail;
47409 }
47410 resultobj = SWIG_From_int(static_cast< int >(result));
47411 return resultobj;
47412 fail:
47413 return NULL;
47414 }
47415
47416
47417 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47418 PyObject *resultobj = 0;
47419 int result;
47420
47421 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47422 {
47423 PyThreadState* __tstate = wxPyBeginAllowThreads();
47424 result = (int)wxMenuItem_GetDefaultMarginWidth();
47425 wxPyEndAllowThreads(__tstate);
47426 if (PyErr_Occurred()) SWIG_fail;
47427 }
47428 resultobj = SWIG_From_int(static_cast< int >(result));
47429 return resultobj;
47430 fail:
47431 return NULL;
47432 }
47433
47434
47435 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47436 PyObject *resultobj = 0;
47437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47438 bool result;
47439 void *argp1 = 0 ;
47440 int res1 = 0 ;
47441 PyObject *swig_obj[1] ;
47442
47443 if (!args) SWIG_fail;
47444 swig_obj[0] = args;
47445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47446 if (!SWIG_IsOK(res1)) {
47447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47448 }
47449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47450 {
47451 PyThreadState* __tstate = wxPyBeginAllowThreads();
47452 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47453 wxPyEndAllowThreads(__tstate);
47454 if (PyErr_Occurred()) SWIG_fail;
47455 }
47456 {
47457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47458 }
47459 return resultobj;
47460 fail:
47461 return NULL;
47462 }
47463
47464
47465 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47466 PyObject *resultobj = 0;
47467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47468 bool arg2 = (bool) true ;
47469 void *argp1 = 0 ;
47470 int res1 = 0 ;
47471 bool val2 ;
47472 int ecode2 = 0 ;
47473 PyObject * obj0 = 0 ;
47474 PyObject * obj1 = 0 ;
47475 char * kwnames[] = {
47476 (char *) "self",(char *) "ownerDrawn", NULL
47477 };
47478
47479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47481 if (!SWIG_IsOK(res1)) {
47482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47483 }
47484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47485 if (obj1) {
47486 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47487 if (!SWIG_IsOK(ecode2)) {
47488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47489 }
47490 arg2 = static_cast< bool >(val2);
47491 }
47492 {
47493 PyThreadState* __tstate = wxPyBeginAllowThreads();
47494 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47495 wxPyEndAllowThreads(__tstate);
47496 if (PyErr_Occurred()) SWIG_fail;
47497 }
47498 resultobj = SWIG_Py_Void();
47499 return resultobj;
47500 fail:
47501 return NULL;
47502 }
47503
47504
47505 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47506 PyObject *resultobj = 0;
47507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47508 void *argp1 = 0 ;
47509 int res1 = 0 ;
47510 PyObject *swig_obj[1] ;
47511
47512 if (!args) SWIG_fail;
47513 swig_obj[0] = args;
47514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47515 if (!SWIG_IsOK(res1)) {
47516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47517 }
47518 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47519 {
47520 PyThreadState* __tstate = wxPyBeginAllowThreads();
47521 wxMenuItem_ResetOwnerDrawn(arg1);
47522 wxPyEndAllowThreads(__tstate);
47523 if (PyErr_Occurred()) SWIG_fail;
47524 }
47525 resultobj = SWIG_Py_Void();
47526 return resultobj;
47527 fail:
47528 return NULL;
47529 }
47530
47531
47532 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47533 PyObject *obj;
47534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47535 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47536 return SWIG_Py_Void();
47537 }
47538
47539 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47540 return SWIG_Python_InitShadowInstance(args);
47541 }
47542
47543 SWIGINTERN int ControlNameStr_set(PyObject *) {
47544 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47545 return 1;
47546 }
47547
47548
47549 SWIGINTERN PyObject *ControlNameStr_get(void) {
47550 PyObject *pyobj = 0;
47551
47552 {
47553 #if wxUSE_UNICODE
47554 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47555 #else
47556 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47557 #endif
47558 }
47559 return pyobj;
47560 }
47561
47562
47563 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47564 PyObject *resultobj = 0;
47565 wxWindow *arg1 = (wxWindow *) 0 ;
47566 int arg2 = (int) -1 ;
47567 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47568 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47569 wxSize const &arg4_defvalue = wxDefaultSize ;
47570 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47571 long arg5 = (long) 0 ;
47572 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47573 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47574 wxString const &arg7_defvalue = wxPyControlNameStr ;
47575 wxString *arg7 = (wxString *) &arg7_defvalue ;
47576 wxControl *result = 0 ;
47577 void *argp1 = 0 ;
47578 int res1 = 0 ;
47579 int val2 ;
47580 int ecode2 = 0 ;
47581 wxPoint temp3 ;
47582 wxSize temp4 ;
47583 long val5 ;
47584 int ecode5 = 0 ;
47585 void *argp6 = 0 ;
47586 int res6 = 0 ;
47587 bool temp7 = false ;
47588 PyObject * obj0 = 0 ;
47589 PyObject * obj1 = 0 ;
47590 PyObject * obj2 = 0 ;
47591 PyObject * obj3 = 0 ;
47592 PyObject * obj4 = 0 ;
47593 PyObject * obj5 = 0 ;
47594 PyObject * obj6 = 0 ;
47595 char * kwnames[] = {
47596 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47597 };
47598
47599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47601 if (!SWIG_IsOK(res1)) {
47602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47603 }
47604 arg1 = reinterpret_cast< wxWindow * >(argp1);
47605 if (obj1) {
47606 ecode2 = SWIG_AsVal_int(obj1, &val2);
47607 if (!SWIG_IsOK(ecode2)) {
47608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47609 }
47610 arg2 = static_cast< int >(val2);
47611 }
47612 if (obj2) {
47613 {
47614 arg3 = &temp3;
47615 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47616 }
47617 }
47618 if (obj3) {
47619 {
47620 arg4 = &temp4;
47621 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47622 }
47623 }
47624 if (obj4) {
47625 ecode5 = SWIG_AsVal_long(obj4, &val5);
47626 if (!SWIG_IsOK(ecode5)) {
47627 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47628 }
47629 arg5 = static_cast< long >(val5);
47630 }
47631 if (obj5) {
47632 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47633 if (!SWIG_IsOK(res6)) {
47634 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47635 }
47636 if (!argp6) {
47637 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47638 }
47639 arg6 = reinterpret_cast< wxValidator * >(argp6);
47640 }
47641 if (obj6) {
47642 {
47643 arg7 = wxString_in_helper(obj6);
47644 if (arg7 == NULL) SWIG_fail;
47645 temp7 = true;
47646 }
47647 }
47648 {
47649 if (!wxPyCheckForApp()) SWIG_fail;
47650 PyThreadState* __tstate = wxPyBeginAllowThreads();
47651 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47652 wxPyEndAllowThreads(__tstate);
47653 if (PyErr_Occurred()) SWIG_fail;
47654 }
47655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47656 {
47657 if (temp7)
47658 delete arg7;
47659 }
47660 return resultobj;
47661 fail:
47662 {
47663 if (temp7)
47664 delete arg7;
47665 }
47666 return NULL;
47667 }
47668
47669
47670 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47671 PyObject *resultobj = 0;
47672 wxControl *result = 0 ;
47673
47674 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47675 {
47676 if (!wxPyCheckForApp()) SWIG_fail;
47677 PyThreadState* __tstate = wxPyBeginAllowThreads();
47678 result = (wxControl *)new wxControl();
47679 wxPyEndAllowThreads(__tstate);
47680 if (PyErr_Occurred()) SWIG_fail;
47681 }
47682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47683 return resultobj;
47684 fail:
47685 return NULL;
47686 }
47687
47688
47689 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47690 PyObject *resultobj = 0;
47691 wxControl *arg1 = (wxControl *) 0 ;
47692 wxWindow *arg2 = (wxWindow *) 0 ;
47693 int arg3 = (int) -1 ;
47694 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47695 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47696 wxSize const &arg5_defvalue = wxDefaultSize ;
47697 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47698 long arg6 = (long) 0 ;
47699 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47700 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47701 wxString const &arg8_defvalue = wxPyControlNameStr ;
47702 wxString *arg8 = (wxString *) &arg8_defvalue ;
47703 bool result;
47704 void *argp1 = 0 ;
47705 int res1 = 0 ;
47706 void *argp2 = 0 ;
47707 int res2 = 0 ;
47708 int val3 ;
47709 int ecode3 = 0 ;
47710 wxPoint temp4 ;
47711 wxSize temp5 ;
47712 long val6 ;
47713 int ecode6 = 0 ;
47714 void *argp7 = 0 ;
47715 int res7 = 0 ;
47716 bool temp8 = false ;
47717 PyObject * obj0 = 0 ;
47718 PyObject * obj1 = 0 ;
47719 PyObject * obj2 = 0 ;
47720 PyObject * obj3 = 0 ;
47721 PyObject * obj4 = 0 ;
47722 PyObject * obj5 = 0 ;
47723 PyObject * obj6 = 0 ;
47724 PyObject * obj7 = 0 ;
47725 char * kwnames[] = {
47726 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47727 };
47728
47729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47731 if (!SWIG_IsOK(res1)) {
47732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47733 }
47734 arg1 = reinterpret_cast< wxControl * >(argp1);
47735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47736 if (!SWIG_IsOK(res2)) {
47737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47738 }
47739 arg2 = reinterpret_cast< wxWindow * >(argp2);
47740 if (obj2) {
47741 ecode3 = SWIG_AsVal_int(obj2, &val3);
47742 if (!SWIG_IsOK(ecode3)) {
47743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47744 }
47745 arg3 = static_cast< int >(val3);
47746 }
47747 if (obj3) {
47748 {
47749 arg4 = &temp4;
47750 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47751 }
47752 }
47753 if (obj4) {
47754 {
47755 arg5 = &temp5;
47756 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47757 }
47758 }
47759 if (obj5) {
47760 ecode6 = SWIG_AsVal_long(obj5, &val6);
47761 if (!SWIG_IsOK(ecode6)) {
47762 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47763 }
47764 arg6 = static_cast< long >(val6);
47765 }
47766 if (obj6) {
47767 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47768 if (!SWIG_IsOK(res7)) {
47769 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47770 }
47771 if (!argp7) {
47772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47773 }
47774 arg7 = reinterpret_cast< wxValidator * >(argp7);
47775 }
47776 if (obj7) {
47777 {
47778 arg8 = wxString_in_helper(obj7);
47779 if (arg8 == NULL) SWIG_fail;
47780 temp8 = true;
47781 }
47782 }
47783 {
47784 PyThreadState* __tstate = wxPyBeginAllowThreads();
47785 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47786 wxPyEndAllowThreads(__tstate);
47787 if (PyErr_Occurred()) SWIG_fail;
47788 }
47789 {
47790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47791 }
47792 {
47793 if (temp8)
47794 delete arg8;
47795 }
47796 return resultobj;
47797 fail:
47798 {
47799 if (temp8)
47800 delete arg8;
47801 }
47802 return NULL;
47803 }
47804
47805
47806 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47807 PyObject *resultobj = 0;
47808 wxControl *arg1 = (wxControl *) 0 ;
47809 int result;
47810 void *argp1 = 0 ;
47811 int res1 = 0 ;
47812 PyObject *swig_obj[1] ;
47813
47814 if (!args) SWIG_fail;
47815 swig_obj[0] = args;
47816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47817 if (!SWIG_IsOK(res1)) {
47818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47819 }
47820 arg1 = reinterpret_cast< wxControl * >(argp1);
47821 {
47822 PyThreadState* __tstate = wxPyBeginAllowThreads();
47823 result = (int)((wxControl const *)arg1)->GetAlignment();
47824 wxPyEndAllowThreads(__tstate);
47825 if (PyErr_Occurred()) SWIG_fail;
47826 }
47827 resultobj = SWIG_From_int(static_cast< int >(result));
47828 return resultobj;
47829 fail:
47830 return NULL;
47831 }
47832
47833
47834 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47835 PyObject *resultobj = 0;
47836 wxControl *arg1 = (wxControl *) 0 ;
47837 wxString result;
47838 void *argp1 = 0 ;
47839 int res1 = 0 ;
47840 PyObject *swig_obj[1] ;
47841
47842 if (!args) SWIG_fail;
47843 swig_obj[0] = args;
47844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47845 if (!SWIG_IsOK(res1)) {
47846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47847 }
47848 arg1 = reinterpret_cast< wxControl * >(argp1);
47849 {
47850 PyThreadState* __tstate = wxPyBeginAllowThreads();
47851 result = ((wxControl const *)arg1)->GetLabelText();
47852 wxPyEndAllowThreads(__tstate);
47853 if (PyErr_Occurred()) SWIG_fail;
47854 }
47855 {
47856 #if wxUSE_UNICODE
47857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47858 #else
47859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47860 #endif
47861 }
47862 return resultobj;
47863 fail:
47864 return NULL;
47865 }
47866
47867
47868 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47869 PyObject *resultobj = 0;
47870 wxControl *arg1 = (wxControl *) 0 ;
47871 wxCommandEvent *arg2 = 0 ;
47872 void *argp1 = 0 ;
47873 int res1 = 0 ;
47874 void *argp2 = 0 ;
47875 int res2 = 0 ;
47876 PyObject * obj0 = 0 ;
47877 PyObject * obj1 = 0 ;
47878 char * kwnames[] = {
47879 (char *) "self",(char *) "event", NULL
47880 };
47881
47882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47884 if (!SWIG_IsOK(res1)) {
47885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47886 }
47887 arg1 = reinterpret_cast< wxControl * >(argp1);
47888 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47889 if (!SWIG_IsOK(res2)) {
47890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47891 }
47892 if (!argp2) {
47893 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47894 }
47895 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47896 {
47897 PyThreadState* __tstate = wxPyBeginAllowThreads();
47898 (arg1)->Command(*arg2);
47899 wxPyEndAllowThreads(__tstate);
47900 if (PyErr_Occurred()) SWIG_fail;
47901 }
47902 resultobj = SWIG_Py_Void();
47903 return resultobj;
47904 fail:
47905 return NULL;
47906 }
47907
47908
47909 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47910 PyObject *resultobj = 0;
47911 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47912 SwigValueWrapper<wxVisualAttributes > result;
47913 int val1 ;
47914 int ecode1 = 0 ;
47915 PyObject * obj0 = 0 ;
47916 char * kwnames[] = {
47917 (char *) "variant", NULL
47918 };
47919
47920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47921 if (obj0) {
47922 ecode1 = SWIG_AsVal_int(obj0, &val1);
47923 if (!SWIG_IsOK(ecode1)) {
47924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47925 }
47926 arg1 = static_cast< wxWindowVariant >(val1);
47927 }
47928 {
47929 if (!wxPyCheckForApp()) SWIG_fail;
47930 PyThreadState* __tstate = wxPyBeginAllowThreads();
47931 result = wxControl::GetClassDefaultAttributes(arg1);
47932 wxPyEndAllowThreads(__tstate);
47933 if (PyErr_Occurred()) SWIG_fail;
47934 }
47935 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47936 return resultobj;
47937 fail:
47938 return NULL;
47939 }
47940
47941
47942 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47943 PyObject *obj;
47944 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47945 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47946 return SWIG_Py_Void();
47947 }
47948
47949 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47950 return SWIG_Python_InitShadowInstance(args);
47951 }
47952
47953 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47954 PyObject *resultobj = 0;
47955 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47956 wxString *arg2 = 0 ;
47957 PyObject *arg3 = (PyObject *) NULL ;
47958 int result;
47959 void *argp1 = 0 ;
47960 int res1 = 0 ;
47961 bool temp2 = false ;
47962 PyObject * obj0 = 0 ;
47963 PyObject * obj1 = 0 ;
47964 PyObject * obj2 = 0 ;
47965 char * kwnames[] = {
47966 (char *) "self",(char *) "item",(char *) "clientData", NULL
47967 };
47968
47969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47971 if (!SWIG_IsOK(res1)) {
47972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47973 }
47974 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47975 {
47976 arg2 = wxString_in_helper(obj1);
47977 if (arg2 == NULL) SWIG_fail;
47978 temp2 = true;
47979 }
47980 if (obj2) {
47981 arg3 = obj2;
47982 }
47983 {
47984 PyThreadState* __tstate = wxPyBeginAllowThreads();
47985 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47986 wxPyEndAllowThreads(__tstate);
47987 if (PyErr_Occurred()) SWIG_fail;
47988 }
47989 resultobj = SWIG_From_int(static_cast< int >(result));
47990 {
47991 if (temp2)
47992 delete arg2;
47993 }
47994 return resultobj;
47995 fail:
47996 {
47997 if (temp2)
47998 delete arg2;
47999 }
48000 return NULL;
48001 }
48002
48003
48004 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48005 PyObject *resultobj = 0;
48006 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48007 wxArrayString *arg2 = 0 ;
48008 void *argp1 = 0 ;
48009 int res1 = 0 ;
48010 bool temp2 = false ;
48011 PyObject * obj0 = 0 ;
48012 PyObject * obj1 = 0 ;
48013 char * kwnames[] = {
48014 (char *) "self",(char *) "strings", NULL
48015 };
48016
48017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48019 if (!SWIG_IsOK(res1)) {
48020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48021 }
48022 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48023 {
48024 if (! PySequence_Check(obj1)) {
48025 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48026 SWIG_fail;
48027 }
48028 arg2 = new wxArrayString;
48029 temp2 = true;
48030 int i, len=PySequence_Length(obj1);
48031 for (i=0; i<len; i++) {
48032 PyObject* item = PySequence_GetItem(obj1, i);
48033 wxString* s = wxString_in_helper(item);
48034 if (PyErr_Occurred()) SWIG_fail;
48035 arg2->Add(*s);
48036 delete s;
48037 Py_DECREF(item);
48038 }
48039 }
48040 {
48041 PyThreadState* __tstate = wxPyBeginAllowThreads();
48042 (arg1)->Append((wxArrayString const &)*arg2);
48043 wxPyEndAllowThreads(__tstate);
48044 if (PyErr_Occurred()) SWIG_fail;
48045 }
48046 resultobj = SWIG_Py_Void();
48047 {
48048 if (temp2) delete arg2;
48049 }
48050 return resultobj;
48051 fail:
48052 {
48053 if (temp2) delete arg2;
48054 }
48055 return NULL;
48056 }
48057
48058
48059 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48060 PyObject *resultobj = 0;
48061 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48062 wxString *arg2 = 0 ;
48063 int arg3 ;
48064 PyObject *arg4 = (PyObject *) NULL ;
48065 int result;
48066 void *argp1 = 0 ;
48067 int res1 = 0 ;
48068 bool temp2 = false ;
48069 int val3 ;
48070 int ecode3 = 0 ;
48071 PyObject * obj0 = 0 ;
48072 PyObject * obj1 = 0 ;
48073 PyObject * obj2 = 0 ;
48074 PyObject * obj3 = 0 ;
48075 char * kwnames[] = {
48076 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48077 };
48078
48079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48081 if (!SWIG_IsOK(res1)) {
48082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48083 }
48084 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48085 {
48086 arg2 = wxString_in_helper(obj1);
48087 if (arg2 == NULL) SWIG_fail;
48088 temp2 = true;
48089 }
48090 ecode3 = SWIG_AsVal_int(obj2, &val3);
48091 if (!SWIG_IsOK(ecode3)) {
48092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48093 }
48094 arg3 = static_cast< int >(val3);
48095 if (obj3) {
48096 arg4 = obj3;
48097 }
48098 {
48099 PyThreadState* __tstate = wxPyBeginAllowThreads();
48100 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48101 wxPyEndAllowThreads(__tstate);
48102 if (PyErr_Occurred()) SWIG_fail;
48103 }
48104 resultobj = SWIG_From_int(static_cast< int >(result));
48105 {
48106 if (temp2)
48107 delete arg2;
48108 }
48109 return resultobj;
48110 fail:
48111 {
48112 if (temp2)
48113 delete arg2;
48114 }
48115 return NULL;
48116 }
48117
48118
48119 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48120 PyObject *resultobj = 0;
48121 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48122 void *argp1 = 0 ;
48123 int res1 = 0 ;
48124 PyObject *swig_obj[1] ;
48125
48126 if (!args) SWIG_fail;
48127 swig_obj[0] = args;
48128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48129 if (!SWIG_IsOK(res1)) {
48130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48131 }
48132 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48133 {
48134 PyThreadState* __tstate = wxPyBeginAllowThreads();
48135 (arg1)->Clear();
48136 wxPyEndAllowThreads(__tstate);
48137 if (PyErr_Occurred()) SWIG_fail;
48138 }
48139 resultobj = SWIG_Py_Void();
48140 return resultobj;
48141 fail:
48142 return NULL;
48143 }
48144
48145
48146 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48147 PyObject *resultobj = 0;
48148 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48149 int arg2 ;
48150 void *argp1 = 0 ;
48151 int res1 = 0 ;
48152 int val2 ;
48153 int ecode2 = 0 ;
48154 PyObject * obj0 = 0 ;
48155 PyObject * obj1 = 0 ;
48156 char * kwnames[] = {
48157 (char *) "self",(char *) "n", NULL
48158 };
48159
48160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48162 if (!SWIG_IsOK(res1)) {
48163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48164 }
48165 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48166 ecode2 = SWIG_AsVal_int(obj1, &val2);
48167 if (!SWIG_IsOK(ecode2)) {
48168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48169 }
48170 arg2 = static_cast< int >(val2);
48171 {
48172 PyThreadState* __tstate = wxPyBeginAllowThreads();
48173 (arg1)->Delete(arg2);
48174 wxPyEndAllowThreads(__tstate);
48175 if (PyErr_Occurred()) SWIG_fail;
48176 }
48177 resultobj = SWIG_Py_Void();
48178 return resultobj;
48179 fail:
48180 return NULL;
48181 }
48182
48183
48184 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48185 PyObject *resultobj = 0;
48186 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48187 int arg2 ;
48188 PyObject *result = 0 ;
48189 void *argp1 = 0 ;
48190 int res1 = 0 ;
48191 int val2 ;
48192 int ecode2 = 0 ;
48193 PyObject * obj0 = 0 ;
48194 PyObject * obj1 = 0 ;
48195 char * kwnames[] = {
48196 (char *) "self",(char *) "n", NULL
48197 };
48198
48199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48201 if (!SWIG_IsOK(res1)) {
48202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48203 }
48204 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48205 ecode2 = SWIG_AsVal_int(obj1, &val2);
48206 if (!SWIG_IsOK(ecode2)) {
48207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48208 }
48209 arg2 = static_cast< int >(val2);
48210 {
48211 PyThreadState* __tstate = wxPyBeginAllowThreads();
48212 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48213 wxPyEndAllowThreads(__tstate);
48214 if (PyErr_Occurred()) SWIG_fail;
48215 }
48216 resultobj = result;
48217 return resultobj;
48218 fail:
48219 return NULL;
48220 }
48221
48222
48223 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48224 PyObject *resultobj = 0;
48225 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48226 int arg2 ;
48227 PyObject *arg3 = (PyObject *) 0 ;
48228 void *argp1 = 0 ;
48229 int res1 = 0 ;
48230 int val2 ;
48231 int ecode2 = 0 ;
48232 PyObject * obj0 = 0 ;
48233 PyObject * obj1 = 0 ;
48234 PyObject * obj2 = 0 ;
48235 char * kwnames[] = {
48236 (char *) "self",(char *) "n",(char *) "clientData", NULL
48237 };
48238
48239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48241 if (!SWIG_IsOK(res1)) {
48242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48243 }
48244 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48245 ecode2 = SWIG_AsVal_int(obj1, &val2);
48246 if (!SWIG_IsOK(ecode2)) {
48247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48248 }
48249 arg2 = static_cast< int >(val2);
48250 arg3 = obj2;
48251 {
48252 PyThreadState* __tstate = wxPyBeginAllowThreads();
48253 wxItemContainer_SetClientData(arg1,arg2,arg3);
48254 wxPyEndAllowThreads(__tstate);
48255 if (PyErr_Occurred()) SWIG_fail;
48256 }
48257 resultobj = SWIG_Py_Void();
48258 return resultobj;
48259 fail:
48260 return NULL;
48261 }
48262
48263
48264 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48265 PyObject *resultobj = 0;
48266 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48267 int result;
48268 void *argp1 = 0 ;
48269 int res1 = 0 ;
48270 PyObject *swig_obj[1] ;
48271
48272 if (!args) SWIG_fail;
48273 swig_obj[0] = args;
48274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48275 if (!SWIG_IsOK(res1)) {
48276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48277 }
48278 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48279 {
48280 PyThreadState* __tstate = wxPyBeginAllowThreads();
48281 result = (int)((wxItemContainer const *)arg1)->GetCount();
48282 wxPyEndAllowThreads(__tstate);
48283 if (PyErr_Occurred()) SWIG_fail;
48284 }
48285 resultobj = SWIG_From_int(static_cast< int >(result));
48286 return resultobj;
48287 fail:
48288 return NULL;
48289 }
48290
48291
48292 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48293 PyObject *resultobj = 0;
48294 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48295 bool result;
48296 void *argp1 = 0 ;
48297 int res1 = 0 ;
48298 PyObject *swig_obj[1] ;
48299
48300 if (!args) SWIG_fail;
48301 swig_obj[0] = args;
48302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48303 if (!SWIG_IsOK(res1)) {
48304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48305 }
48306 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48307 {
48308 PyThreadState* __tstate = wxPyBeginAllowThreads();
48309 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48310 wxPyEndAllowThreads(__tstate);
48311 if (PyErr_Occurred()) SWIG_fail;
48312 }
48313 {
48314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48315 }
48316 return resultobj;
48317 fail:
48318 return NULL;
48319 }
48320
48321
48322 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48323 PyObject *resultobj = 0;
48324 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48325 int arg2 ;
48326 wxString result;
48327 void *argp1 = 0 ;
48328 int res1 = 0 ;
48329 int val2 ;
48330 int ecode2 = 0 ;
48331 PyObject * obj0 = 0 ;
48332 PyObject * obj1 = 0 ;
48333 char * kwnames[] = {
48334 (char *) "self",(char *) "n", NULL
48335 };
48336
48337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48339 if (!SWIG_IsOK(res1)) {
48340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48341 }
48342 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48343 ecode2 = SWIG_AsVal_int(obj1, &val2);
48344 if (!SWIG_IsOK(ecode2)) {
48345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48346 }
48347 arg2 = static_cast< int >(val2);
48348 {
48349 PyThreadState* __tstate = wxPyBeginAllowThreads();
48350 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48351 wxPyEndAllowThreads(__tstate);
48352 if (PyErr_Occurred()) SWIG_fail;
48353 }
48354 {
48355 #if wxUSE_UNICODE
48356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48357 #else
48358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48359 #endif
48360 }
48361 return resultobj;
48362 fail:
48363 return NULL;
48364 }
48365
48366
48367 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48368 PyObject *resultobj = 0;
48369 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48370 wxArrayString result;
48371 void *argp1 = 0 ;
48372 int res1 = 0 ;
48373 PyObject *swig_obj[1] ;
48374
48375 if (!args) SWIG_fail;
48376 swig_obj[0] = args;
48377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48378 if (!SWIG_IsOK(res1)) {
48379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48380 }
48381 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48382 {
48383 PyThreadState* __tstate = wxPyBeginAllowThreads();
48384 result = ((wxItemContainer const *)arg1)->GetStrings();
48385 wxPyEndAllowThreads(__tstate);
48386 if (PyErr_Occurred()) SWIG_fail;
48387 }
48388 {
48389 resultobj = wxArrayString2PyList_helper(result);
48390 }
48391 return resultobj;
48392 fail:
48393 return NULL;
48394 }
48395
48396
48397 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48398 PyObject *resultobj = 0;
48399 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48400 int arg2 ;
48401 wxString *arg3 = 0 ;
48402 void *argp1 = 0 ;
48403 int res1 = 0 ;
48404 int val2 ;
48405 int ecode2 = 0 ;
48406 bool temp3 = false ;
48407 PyObject * obj0 = 0 ;
48408 PyObject * obj1 = 0 ;
48409 PyObject * obj2 = 0 ;
48410 char * kwnames[] = {
48411 (char *) "self",(char *) "n",(char *) "s", NULL
48412 };
48413
48414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48416 if (!SWIG_IsOK(res1)) {
48417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48418 }
48419 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48420 ecode2 = SWIG_AsVal_int(obj1, &val2);
48421 if (!SWIG_IsOK(ecode2)) {
48422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48423 }
48424 arg2 = static_cast< int >(val2);
48425 {
48426 arg3 = wxString_in_helper(obj2);
48427 if (arg3 == NULL) SWIG_fail;
48428 temp3 = true;
48429 }
48430 {
48431 PyThreadState* __tstate = wxPyBeginAllowThreads();
48432 (arg1)->SetString(arg2,(wxString const &)*arg3);
48433 wxPyEndAllowThreads(__tstate);
48434 if (PyErr_Occurred()) SWIG_fail;
48435 }
48436 resultobj = SWIG_Py_Void();
48437 {
48438 if (temp3)
48439 delete arg3;
48440 }
48441 return resultobj;
48442 fail:
48443 {
48444 if (temp3)
48445 delete arg3;
48446 }
48447 return NULL;
48448 }
48449
48450
48451 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48452 PyObject *resultobj = 0;
48453 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48454 wxString *arg2 = 0 ;
48455 int result;
48456 void *argp1 = 0 ;
48457 int res1 = 0 ;
48458 bool temp2 = false ;
48459 PyObject * obj0 = 0 ;
48460 PyObject * obj1 = 0 ;
48461 char * kwnames[] = {
48462 (char *) "self",(char *) "s", NULL
48463 };
48464
48465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48467 if (!SWIG_IsOK(res1)) {
48468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48469 }
48470 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48471 {
48472 arg2 = wxString_in_helper(obj1);
48473 if (arg2 == NULL) SWIG_fail;
48474 temp2 = true;
48475 }
48476 {
48477 PyThreadState* __tstate = wxPyBeginAllowThreads();
48478 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48479 wxPyEndAllowThreads(__tstate);
48480 if (PyErr_Occurred()) SWIG_fail;
48481 }
48482 resultobj = SWIG_From_int(static_cast< int >(result));
48483 {
48484 if (temp2)
48485 delete arg2;
48486 }
48487 return resultobj;
48488 fail:
48489 {
48490 if (temp2)
48491 delete arg2;
48492 }
48493 return NULL;
48494 }
48495
48496
48497 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48498 PyObject *resultobj = 0;
48499 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48500 int arg2 ;
48501 void *argp1 = 0 ;
48502 int res1 = 0 ;
48503 int val2 ;
48504 int ecode2 = 0 ;
48505 PyObject * obj0 = 0 ;
48506 PyObject * obj1 = 0 ;
48507 char * kwnames[] = {
48508 (char *) "self",(char *) "n", NULL
48509 };
48510
48511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48513 if (!SWIG_IsOK(res1)) {
48514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48515 }
48516 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48517 ecode2 = SWIG_AsVal_int(obj1, &val2);
48518 if (!SWIG_IsOK(ecode2)) {
48519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48520 }
48521 arg2 = static_cast< int >(val2);
48522 {
48523 PyThreadState* __tstate = wxPyBeginAllowThreads();
48524 (arg1)->SetSelection(arg2);
48525 wxPyEndAllowThreads(__tstate);
48526 if (PyErr_Occurred()) SWIG_fail;
48527 }
48528 resultobj = SWIG_Py_Void();
48529 return resultobj;
48530 fail:
48531 return NULL;
48532 }
48533
48534
48535 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48536 PyObject *resultobj = 0;
48537 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48538 int result;
48539 void *argp1 = 0 ;
48540 int res1 = 0 ;
48541 PyObject *swig_obj[1] ;
48542
48543 if (!args) SWIG_fail;
48544 swig_obj[0] = args;
48545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48546 if (!SWIG_IsOK(res1)) {
48547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48548 }
48549 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48550 {
48551 PyThreadState* __tstate = wxPyBeginAllowThreads();
48552 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48553 wxPyEndAllowThreads(__tstate);
48554 if (PyErr_Occurred()) SWIG_fail;
48555 }
48556 resultobj = SWIG_From_int(static_cast< int >(result));
48557 return resultobj;
48558 fail:
48559 return NULL;
48560 }
48561
48562
48563 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48564 PyObject *resultobj = 0;
48565 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48566 wxString *arg2 = 0 ;
48567 bool result;
48568 void *argp1 = 0 ;
48569 int res1 = 0 ;
48570 bool temp2 = false ;
48571 PyObject * obj0 = 0 ;
48572 PyObject * obj1 = 0 ;
48573 char * kwnames[] = {
48574 (char *) "self",(char *) "s", NULL
48575 };
48576
48577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48579 if (!SWIG_IsOK(res1)) {
48580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48581 }
48582 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48583 {
48584 arg2 = wxString_in_helper(obj1);
48585 if (arg2 == NULL) SWIG_fail;
48586 temp2 = true;
48587 }
48588 {
48589 PyThreadState* __tstate = wxPyBeginAllowThreads();
48590 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48591 wxPyEndAllowThreads(__tstate);
48592 if (PyErr_Occurred()) SWIG_fail;
48593 }
48594 {
48595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48596 }
48597 {
48598 if (temp2)
48599 delete arg2;
48600 }
48601 return resultobj;
48602 fail:
48603 {
48604 if (temp2)
48605 delete arg2;
48606 }
48607 return NULL;
48608 }
48609
48610
48611 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48612 PyObject *resultobj = 0;
48613 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48614 wxString result;
48615 void *argp1 = 0 ;
48616 int res1 = 0 ;
48617 PyObject *swig_obj[1] ;
48618
48619 if (!args) SWIG_fail;
48620 swig_obj[0] = args;
48621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48622 if (!SWIG_IsOK(res1)) {
48623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48624 }
48625 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48626 {
48627 PyThreadState* __tstate = wxPyBeginAllowThreads();
48628 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48629 wxPyEndAllowThreads(__tstate);
48630 if (PyErr_Occurred()) SWIG_fail;
48631 }
48632 {
48633 #if wxUSE_UNICODE
48634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48635 #else
48636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48637 #endif
48638 }
48639 return resultobj;
48640 fail:
48641 return NULL;
48642 }
48643
48644
48645 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48646 PyObject *resultobj = 0;
48647 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48648 int arg2 ;
48649 void *argp1 = 0 ;
48650 int res1 = 0 ;
48651 int val2 ;
48652 int ecode2 = 0 ;
48653 PyObject * obj0 = 0 ;
48654 PyObject * obj1 = 0 ;
48655 char * kwnames[] = {
48656 (char *) "self",(char *) "n", NULL
48657 };
48658
48659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48661 if (!SWIG_IsOK(res1)) {
48662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48663 }
48664 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48665 ecode2 = SWIG_AsVal_int(obj1, &val2);
48666 if (!SWIG_IsOK(ecode2)) {
48667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48668 }
48669 arg2 = static_cast< int >(val2);
48670 {
48671 PyThreadState* __tstate = wxPyBeginAllowThreads();
48672 (arg1)->Select(arg2);
48673 wxPyEndAllowThreads(__tstate);
48674 if (PyErr_Occurred()) SWIG_fail;
48675 }
48676 resultobj = SWIG_Py_Void();
48677 return resultobj;
48678 fail:
48679 return NULL;
48680 }
48681
48682
48683 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48684 PyObject *obj;
48685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48686 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48687 return SWIG_Py_Void();
48688 }
48689
48690 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48691 PyObject *obj;
48692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48693 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48694 return SWIG_Py_Void();
48695 }
48696
48697 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48698 PyObject *resultobj = 0;
48699 int arg1 = (int) 0 ;
48700 wxSizerFlags *result = 0 ;
48701 int val1 ;
48702 int ecode1 = 0 ;
48703 PyObject * obj0 = 0 ;
48704 char * kwnames[] = {
48705 (char *) "proportion", NULL
48706 };
48707
48708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
48709 if (obj0) {
48710 ecode1 = SWIG_AsVal_int(obj0, &val1);
48711 if (!SWIG_IsOK(ecode1)) {
48712 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
48713 }
48714 arg1 = static_cast< int >(val1);
48715 }
48716 {
48717 PyThreadState* __tstate = wxPyBeginAllowThreads();
48718 result = (wxSizerFlags *)new wxSizerFlags(arg1);
48719 wxPyEndAllowThreads(__tstate);
48720 if (PyErr_Occurred()) SWIG_fail;
48721 }
48722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
48723 return resultobj;
48724 fail:
48725 return NULL;
48726 }
48727
48728
48729 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48730 PyObject *resultobj = 0;
48731 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48732 void *argp1 = 0 ;
48733 int res1 = 0 ;
48734 PyObject *swig_obj[1] ;
48735
48736 if (!args) SWIG_fail;
48737 swig_obj[0] = args;
48738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
48739 if (!SWIG_IsOK(res1)) {
48740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48741 }
48742 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48743 {
48744 PyThreadState* __tstate = wxPyBeginAllowThreads();
48745 delete arg1;
48746
48747 wxPyEndAllowThreads(__tstate);
48748 if (PyErr_Occurred()) SWIG_fail;
48749 }
48750 resultobj = SWIG_Py_Void();
48751 return resultobj;
48752 fail:
48753 return NULL;
48754 }
48755
48756
48757 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48758 PyObject *resultobj = 0;
48759 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48760 int arg2 ;
48761 wxSizerFlags *result = 0 ;
48762 void *argp1 = 0 ;
48763 int res1 = 0 ;
48764 int val2 ;
48765 int ecode2 = 0 ;
48766 PyObject * obj0 = 0 ;
48767 PyObject * obj1 = 0 ;
48768 char * kwnames[] = {
48769 (char *) "self",(char *) "proportion", NULL
48770 };
48771
48772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
48773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48774 if (!SWIG_IsOK(res1)) {
48775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48776 }
48777 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48778 ecode2 = SWIG_AsVal_int(obj1, &val2);
48779 if (!SWIG_IsOK(ecode2)) {
48780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
48781 }
48782 arg2 = static_cast< int >(val2);
48783 {
48784 PyThreadState* __tstate = wxPyBeginAllowThreads();
48785 {
48786 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
48787 result = (wxSizerFlags *) &_result_ref;
48788 }
48789 wxPyEndAllowThreads(__tstate);
48790 if (PyErr_Occurred()) SWIG_fail;
48791 }
48792 {
48793 resultobj = obj0; Py_INCREF(resultobj);
48794 }
48795 return resultobj;
48796 fail:
48797 return NULL;
48798 }
48799
48800
48801 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48802 PyObject *resultobj = 0;
48803 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48804 int arg2 ;
48805 wxSizerFlags *result = 0 ;
48806 void *argp1 = 0 ;
48807 int res1 = 0 ;
48808 int val2 ;
48809 int ecode2 = 0 ;
48810 PyObject * obj0 = 0 ;
48811 PyObject * obj1 = 0 ;
48812 char * kwnames[] = {
48813 (char *) "self",(char *) "alignment", NULL
48814 };
48815
48816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
48817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48818 if (!SWIG_IsOK(res1)) {
48819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48820 }
48821 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48822 ecode2 = SWIG_AsVal_int(obj1, &val2);
48823 if (!SWIG_IsOK(ecode2)) {
48824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
48825 }
48826 arg2 = static_cast< int >(val2);
48827 {
48828 PyThreadState* __tstate = wxPyBeginAllowThreads();
48829 {
48830 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
48831 result = (wxSizerFlags *) &_result_ref;
48832 }
48833 wxPyEndAllowThreads(__tstate);
48834 if (PyErr_Occurred()) SWIG_fail;
48835 }
48836 {
48837 resultobj = obj0; Py_INCREF(resultobj);
48838 }
48839 return resultobj;
48840 fail:
48841 return NULL;
48842 }
48843
48844
48845 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48846 PyObject *resultobj = 0;
48847 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48848 wxSizerFlags *result = 0 ;
48849 void *argp1 = 0 ;
48850 int res1 = 0 ;
48851 PyObject *swig_obj[1] ;
48852
48853 if (!args) SWIG_fail;
48854 swig_obj[0] = args;
48855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48856 if (!SWIG_IsOK(res1)) {
48857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48858 }
48859 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48860 {
48861 PyThreadState* __tstate = wxPyBeginAllowThreads();
48862 {
48863 wxSizerFlags &_result_ref = (arg1)->Expand();
48864 result = (wxSizerFlags *) &_result_ref;
48865 }
48866 wxPyEndAllowThreads(__tstate);
48867 if (PyErr_Occurred()) SWIG_fail;
48868 }
48869 {
48870 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48871 }
48872 return resultobj;
48873 fail:
48874 return NULL;
48875 }
48876
48877
48878 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48879 PyObject *resultobj = 0;
48880 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48881 wxSizerFlags *result = 0 ;
48882 void *argp1 = 0 ;
48883 int res1 = 0 ;
48884 PyObject *swig_obj[1] ;
48885
48886 if (!args) SWIG_fail;
48887 swig_obj[0] = args;
48888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48889 if (!SWIG_IsOK(res1)) {
48890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48891 }
48892 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48893 {
48894 PyThreadState* __tstate = wxPyBeginAllowThreads();
48895 {
48896 wxSizerFlags &_result_ref = (arg1)->Centre();
48897 result = (wxSizerFlags *) &_result_ref;
48898 }
48899 wxPyEndAllowThreads(__tstate);
48900 if (PyErr_Occurred()) SWIG_fail;
48901 }
48902 {
48903 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48904 }
48905 return resultobj;
48906 fail:
48907 return NULL;
48908 }
48909
48910
48911 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48912 PyObject *resultobj = 0;
48913 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48914 wxSizerFlags *result = 0 ;
48915 void *argp1 = 0 ;
48916 int res1 = 0 ;
48917 PyObject *swig_obj[1] ;
48918
48919 if (!args) SWIG_fail;
48920 swig_obj[0] = args;
48921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48922 if (!SWIG_IsOK(res1)) {
48923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48924 }
48925 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48926 {
48927 PyThreadState* __tstate = wxPyBeginAllowThreads();
48928 {
48929 wxSizerFlags &_result_ref = (arg1)->Center();
48930 result = (wxSizerFlags *) &_result_ref;
48931 }
48932 wxPyEndAllowThreads(__tstate);
48933 if (PyErr_Occurred()) SWIG_fail;
48934 }
48935 {
48936 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48937 }
48938 return resultobj;
48939 fail:
48940 return NULL;
48941 }
48942
48943
48944 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48945 PyObject *resultobj = 0;
48946 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48947 wxSizerFlags *result = 0 ;
48948 void *argp1 = 0 ;
48949 int res1 = 0 ;
48950 PyObject *swig_obj[1] ;
48951
48952 if (!args) SWIG_fail;
48953 swig_obj[0] = args;
48954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48955 if (!SWIG_IsOK(res1)) {
48956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48957 }
48958 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48959 {
48960 PyThreadState* __tstate = wxPyBeginAllowThreads();
48961 {
48962 wxSizerFlags &_result_ref = (arg1)->Left();
48963 result = (wxSizerFlags *) &_result_ref;
48964 }
48965 wxPyEndAllowThreads(__tstate);
48966 if (PyErr_Occurred()) SWIG_fail;
48967 }
48968 {
48969 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48970 }
48971 return resultobj;
48972 fail:
48973 return NULL;
48974 }
48975
48976
48977 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48978 PyObject *resultobj = 0;
48979 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48980 wxSizerFlags *result = 0 ;
48981 void *argp1 = 0 ;
48982 int res1 = 0 ;
48983 PyObject *swig_obj[1] ;
48984
48985 if (!args) SWIG_fail;
48986 swig_obj[0] = args;
48987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48988 if (!SWIG_IsOK(res1)) {
48989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48990 }
48991 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48992 {
48993 PyThreadState* __tstate = wxPyBeginAllowThreads();
48994 {
48995 wxSizerFlags &_result_ref = (arg1)->Right();
48996 result = (wxSizerFlags *) &_result_ref;
48997 }
48998 wxPyEndAllowThreads(__tstate);
48999 if (PyErr_Occurred()) SWIG_fail;
49000 }
49001 {
49002 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49003 }
49004 return resultobj;
49005 fail:
49006 return NULL;
49007 }
49008
49009
49010 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49011 PyObject *resultobj = 0;
49012 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49013 wxSizerFlags *result = 0 ;
49014 void *argp1 = 0 ;
49015 int res1 = 0 ;
49016 PyObject *swig_obj[1] ;
49017
49018 if (!args) SWIG_fail;
49019 swig_obj[0] = args;
49020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49021 if (!SWIG_IsOK(res1)) {
49022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49023 }
49024 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49025 {
49026 PyThreadState* __tstate = wxPyBeginAllowThreads();
49027 {
49028 wxSizerFlags &_result_ref = (arg1)->Top();
49029 result = (wxSizerFlags *) &_result_ref;
49030 }
49031 wxPyEndAllowThreads(__tstate);
49032 if (PyErr_Occurred()) SWIG_fail;
49033 }
49034 {
49035 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49036 }
49037 return resultobj;
49038 fail:
49039 return NULL;
49040 }
49041
49042
49043 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49044 PyObject *resultobj = 0;
49045 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49046 wxSizerFlags *result = 0 ;
49047 void *argp1 = 0 ;
49048 int res1 = 0 ;
49049 PyObject *swig_obj[1] ;
49050
49051 if (!args) SWIG_fail;
49052 swig_obj[0] = args;
49053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49054 if (!SWIG_IsOK(res1)) {
49055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49056 }
49057 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49058 {
49059 PyThreadState* __tstate = wxPyBeginAllowThreads();
49060 {
49061 wxSizerFlags &_result_ref = (arg1)->Bottom();
49062 result = (wxSizerFlags *) &_result_ref;
49063 }
49064 wxPyEndAllowThreads(__tstate);
49065 if (PyErr_Occurred()) SWIG_fail;
49066 }
49067 {
49068 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49069 }
49070 return resultobj;
49071 fail:
49072 return NULL;
49073 }
49074
49075
49076 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49077 PyObject *resultobj = 0;
49078 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49079 wxSizerFlags *result = 0 ;
49080 void *argp1 = 0 ;
49081 int res1 = 0 ;
49082 PyObject *swig_obj[1] ;
49083
49084 if (!args) SWIG_fail;
49085 swig_obj[0] = args;
49086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49087 if (!SWIG_IsOK(res1)) {
49088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49089 }
49090 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49091 {
49092 PyThreadState* __tstate = wxPyBeginAllowThreads();
49093 {
49094 wxSizerFlags &_result_ref = (arg1)->Shaped();
49095 result = (wxSizerFlags *) &_result_ref;
49096 }
49097 wxPyEndAllowThreads(__tstate);
49098 if (PyErr_Occurred()) SWIG_fail;
49099 }
49100 {
49101 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49102 }
49103 return resultobj;
49104 fail:
49105 return NULL;
49106 }
49107
49108
49109 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49110 PyObject *resultobj = 0;
49111 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49112 wxSizerFlags *result = 0 ;
49113 void *argp1 = 0 ;
49114 int res1 = 0 ;
49115 PyObject *swig_obj[1] ;
49116
49117 if (!args) SWIG_fail;
49118 swig_obj[0] = args;
49119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49120 if (!SWIG_IsOK(res1)) {
49121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49122 }
49123 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49124 {
49125 PyThreadState* __tstate = wxPyBeginAllowThreads();
49126 {
49127 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49128 result = (wxSizerFlags *) &_result_ref;
49129 }
49130 wxPyEndAllowThreads(__tstate);
49131 if (PyErr_Occurred()) SWIG_fail;
49132 }
49133 {
49134 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49135 }
49136 return resultobj;
49137 fail:
49138 return NULL;
49139 }
49140
49141
49142 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49143 PyObject *resultobj = 0;
49144 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49145 int arg2 = (int) wxALL ;
49146 int arg3 = (int) -1 ;
49147 wxSizerFlags *result = 0 ;
49148 void *argp1 = 0 ;
49149 int res1 = 0 ;
49150 int val2 ;
49151 int ecode2 = 0 ;
49152 int val3 ;
49153 int ecode3 = 0 ;
49154 PyObject * obj0 = 0 ;
49155 PyObject * obj1 = 0 ;
49156 PyObject * obj2 = 0 ;
49157 char * kwnames[] = {
49158 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49159 };
49160
49161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49163 if (!SWIG_IsOK(res1)) {
49164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49165 }
49166 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49167 if (obj1) {
49168 ecode2 = SWIG_AsVal_int(obj1, &val2);
49169 if (!SWIG_IsOK(ecode2)) {
49170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49171 }
49172 arg2 = static_cast< int >(val2);
49173 }
49174 if (obj2) {
49175 ecode3 = SWIG_AsVal_int(obj2, &val3);
49176 if (!SWIG_IsOK(ecode3)) {
49177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49178 }
49179 arg3 = static_cast< int >(val3);
49180 }
49181 {
49182 PyThreadState* __tstate = wxPyBeginAllowThreads();
49183 {
49184 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49185 result = (wxSizerFlags *) &_result_ref;
49186 }
49187 wxPyEndAllowThreads(__tstate);
49188 if (PyErr_Occurred()) SWIG_fail;
49189 }
49190 {
49191 resultobj = obj0; Py_INCREF(resultobj);
49192 }
49193 return resultobj;
49194 fail:
49195 return NULL;
49196 }
49197
49198
49199 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49200 PyObject *resultobj = 0;
49201 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49202 int arg2 = (int) wxALL ;
49203 wxSizerFlags *result = 0 ;
49204 void *argp1 = 0 ;
49205 int res1 = 0 ;
49206 int val2 ;
49207 int ecode2 = 0 ;
49208 PyObject * obj0 = 0 ;
49209 PyObject * obj1 = 0 ;
49210 char * kwnames[] = {
49211 (char *) "self",(char *) "direction", NULL
49212 };
49213
49214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49216 if (!SWIG_IsOK(res1)) {
49217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49218 }
49219 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49220 if (obj1) {
49221 ecode2 = SWIG_AsVal_int(obj1, &val2);
49222 if (!SWIG_IsOK(ecode2)) {
49223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49224 }
49225 arg2 = static_cast< int >(val2);
49226 }
49227 {
49228 PyThreadState* __tstate = wxPyBeginAllowThreads();
49229 {
49230 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49231 result = (wxSizerFlags *) &_result_ref;
49232 }
49233 wxPyEndAllowThreads(__tstate);
49234 if (PyErr_Occurred()) SWIG_fail;
49235 }
49236 {
49237 resultobj = obj0; Py_INCREF(resultobj);
49238 }
49239 return resultobj;
49240 fail:
49241 return NULL;
49242 }
49243
49244
49245 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49246 PyObject *resultobj = 0;
49247 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49248 int arg2 = (int) wxALL ;
49249 wxSizerFlags *result = 0 ;
49250 void *argp1 = 0 ;
49251 int res1 = 0 ;
49252 int val2 ;
49253 int ecode2 = 0 ;
49254 PyObject * obj0 = 0 ;
49255 PyObject * obj1 = 0 ;
49256 char * kwnames[] = {
49257 (char *) "self",(char *) "direction", NULL
49258 };
49259
49260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49262 if (!SWIG_IsOK(res1)) {
49263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49264 }
49265 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49266 if (obj1) {
49267 ecode2 = SWIG_AsVal_int(obj1, &val2);
49268 if (!SWIG_IsOK(ecode2)) {
49269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49270 }
49271 arg2 = static_cast< int >(val2);
49272 }
49273 {
49274 PyThreadState* __tstate = wxPyBeginAllowThreads();
49275 {
49276 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49277 result = (wxSizerFlags *) &_result_ref;
49278 }
49279 wxPyEndAllowThreads(__tstate);
49280 if (PyErr_Occurred()) SWIG_fail;
49281 }
49282 {
49283 resultobj = obj0; Py_INCREF(resultobj);
49284 }
49285 return resultobj;
49286 fail:
49287 return NULL;
49288 }
49289
49290
49291 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49292 PyObject *resultobj = 0;
49293 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49294 wxSizerFlags *result = 0 ;
49295 void *argp1 = 0 ;
49296 int res1 = 0 ;
49297 PyObject *swig_obj[1] ;
49298
49299 if (!args) SWIG_fail;
49300 swig_obj[0] = args;
49301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49302 if (!SWIG_IsOK(res1)) {
49303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49304 }
49305 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49306 {
49307 PyThreadState* __tstate = wxPyBeginAllowThreads();
49308 {
49309 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49310 result = (wxSizerFlags *) &_result_ref;
49311 }
49312 wxPyEndAllowThreads(__tstate);
49313 if (PyErr_Occurred()) SWIG_fail;
49314 }
49315 {
49316 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49317 }
49318 return resultobj;
49319 fail:
49320 return NULL;
49321 }
49322
49323
49324 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49325 PyObject *resultobj = 0;
49326 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49327 wxSizerFlags *result = 0 ;
49328 void *argp1 = 0 ;
49329 int res1 = 0 ;
49330 PyObject *swig_obj[1] ;
49331
49332 if (!args) SWIG_fail;
49333 swig_obj[0] = args;
49334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49335 if (!SWIG_IsOK(res1)) {
49336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49337 }
49338 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49339 {
49340 PyThreadState* __tstate = wxPyBeginAllowThreads();
49341 {
49342 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49343 result = (wxSizerFlags *) &_result_ref;
49344 }
49345 wxPyEndAllowThreads(__tstate);
49346 if (PyErr_Occurred()) SWIG_fail;
49347 }
49348 {
49349 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49350 }
49351 return resultobj;
49352 fail:
49353 return NULL;
49354 }
49355
49356
49357 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49358 PyObject *resultobj = 0;
49359 int result;
49360
49361 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49362 {
49363 PyThreadState* __tstate = wxPyBeginAllowThreads();
49364 result = (int)wxSizerFlags::GetDefaultBorder();
49365 wxPyEndAllowThreads(__tstate);
49366 if (PyErr_Occurred()) SWIG_fail;
49367 }
49368 resultobj = SWIG_From_int(static_cast< int >(result));
49369 return resultobj;
49370 fail:
49371 return NULL;
49372 }
49373
49374
49375 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49376 PyObject *resultobj = 0;
49377 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49378 int result;
49379 void *argp1 = 0 ;
49380 int res1 = 0 ;
49381 PyObject *swig_obj[1] ;
49382
49383 if (!args) SWIG_fail;
49384 swig_obj[0] = args;
49385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49386 if (!SWIG_IsOK(res1)) {
49387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49388 }
49389 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49390 {
49391 PyThreadState* __tstate = wxPyBeginAllowThreads();
49392 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49393 wxPyEndAllowThreads(__tstate);
49394 if (PyErr_Occurred()) SWIG_fail;
49395 }
49396 resultobj = SWIG_From_int(static_cast< int >(result));
49397 return resultobj;
49398 fail:
49399 return NULL;
49400 }
49401
49402
49403 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49404 PyObject *resultobj = 0;
49405 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49406 int result;
49407 void *argp1 = 0 ;
49408 int res1 = 0 ;
49409 PyObject *swig_obj[1] ;
49410
49411 if (!args) SWIG_fail;
49412 swig_obj[0] = args;
49413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49414 if (!SWIG_IsOK(res1)) {
49415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49416 }
49417 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49418 {
49419 PyThreadState* __tstate = wxPyBeginAllowThreads();
49420 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
49421 wxPyEndAllowThreads(__tstate);
49422 if (PyErr_Occurred()) SWIG_fail;
49423 }
49424 resultobj = SWIG_From_int(static_cast< int >(result));
49425 return resultobj;
49426 fail:
49427 return NULL;
49428 }
49429
49430
49431 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49432 PyObject *resultobj = 0;
49433 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49434 int result;
49435 void *argp1 = 0 ;
49436 int res1 = 0 ;
49437 PyObject *swig_obj[1] ;
49438
49439 if (!args) SWIG_fail;
49440 swig_obj[0] = args;
49441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49442 if (!SWIG_IsOK(res1)) {
49443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49444 }
49445 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49446 {
49447 PyThreadState* __tstate = wxPyBeginAllowThreads();
49448 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
49449 wxPyEndAllowThreads(__tstate);
49450 if (PyErr_Occurred()) SWIG_fail;
49451 }
49452 resultobj = SWIG_From_int(static_cast< int >(result));
49453 return resultobj;
49454 fail:
49455 return NULL;
49456 }
49457
49458
49459 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49460 PyObject *obj;
49461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49462 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
49463 return SWIG_Py_Void();
49464 }
49465
49466 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49467 return SWIG_Python_InitShadowInstance(args);
49468 }
49469
49470 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49471 PyObject *resultobj = 0;
49472 wxSizerItem *result = 0 ;
49473
49474 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
49475 {
49476 PyThreadState* __tstate = wxPyBeginAllowThreads();
49477 result = (wxSizerItem *)new wxSizerItem();
49478 wxPyEndAllowThreads(__tstate);
49479 if (PyErr_Occurred()) SWIG_fail;
49480 }
49481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
49482 return resultobj;
49483 fail:
49484 return NULL;
49485 }
49486
49487
49488 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49489 PyObject *resultobj = 0;
49490 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49491 void *argp1 = 0 ;
49492 int res1 = 0 ;
49493 PyObject *swig_obj[1] ;
49494
49495 if (!args) SWIG_fail;
49496 swig_obj[0] = args;
49497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
49498 if (!SWIG_IsOK(res1)) {
49499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49500 }
49501 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49502 {
49503 PyThreadState* __tstate = wxPyBeginAllowThreads();
49504 delete arg1;
49505
49506 wxPyEndAllowThreads(__tstate);
49507 if (PyErr_Occurred()) SWIG_fail;
49508 }
49509 resultobj = SWIG_Py_Void();
49510 return resultobj;
49511 fail:
49512 return NULL;
49513 }
49514
49515
49516 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49517 PyObject *resultobj = 0;
49518 wxWindow *arg1 = (wxWindow *) 0 ;
49519 int arg2 ;
49520 int arg3 ;
49521 int arg4 ;
49522 PyObject *arg5 = (PyObject *) NULL ;
49523 wxSizerItem *result = 0 ;
49524 void *argp1 = 0 ;
49525 int res1 = 0 ;
49526 int val2 ;
49527 int ecode2 = 0 ;
49528 int val3 ;
49529 int ecode3 = 0 ;
49530 int val4 ;
49531 int ecode4 = 0 ;
49532 PyObject * obj0 = 0 ;
49533 PyObject * obj1 = 0 ;
49534 PyObject * obj2 = 0 ;
49535 PyObject * obj3 = 0 ;
49536 PyObject * obj4 = 0 ;
49537 char * kwnames[] = {
49538 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49539 };
49540
49541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49543 if (!SWIG_IsOK(res1)) {
49544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49545 }
49546 arg1 = reinterpret_cast< wxWindow * >(argp1);
49547 ecode2 = SWIG_AsVal_int(obj1, &val2);
49548 if (!SWIG_IsOK(ecode2)) {
49549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
49550 }
49551 arg2 = static_cast< int >(val2);
49552 ecode3 = SWIG_AsVal_int(obj2, &val3);
49553 if (!SWIG_IsOK(ecode3)) {
49554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
49555 }
49556 arg3 = static_cast< int >(val3);
49557 ecode4 = SWIG_AsVal_int(obj3, &val4);
49558 if (!SWIG_IsOK(ecode4)) {
49559 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49560 }
49561 arg4 = static_cast< int >(val4);
49562 if (obj4) {
49563 arg5 = obj4;
49564 }
49565 {
49566 PyThreadState* __tstate = wxPyBeginAllowThreads();
49567 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49568 wxPyEndAllowThreads(__tstate);
49569 if (PyErr_Occurred()) SWIG_fail;
49570 }
49571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49572 return resultobj;
49573 fail:
49574 return NULL;
49575 }
49576
49577
49578 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49579 PyObject *resultobj = 0;
49580 int arg1 ;
49581 int arg2 ;
49582 int arg3 ;
49583 int arg4 ;
49584 int arg5 ;
49585 PyObject *arg6 = (PyObject *) NULL ;
49586 wxSizerItem *result = 0 ;
49587 int val1 ;
49588 int ecode1 = 0 ;
49589 int val2 ;
49590 int ecode2 = 0 ;
49591 int val3 ;
49592 int ecode3 = 0 ;
49593 int val4 ;
49594 int ecode4 = 0 ;
49595 int val5 ;
49596 int ecode5 = 0 ;
49597 PyObject * obj0 = 0 ;
49598 PyObject * obj1 = 0 ;
49599 PyObject * obj2 = 0 ;
49600 PyObject * obj3 = 0 ;
49601 PyObject * obj4 = 0 ;
49602 PyObject * obj5 = 0 ;
49603 char * kwnames[] = {
49604 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49605 };
49606
49607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49608 ecode1 = SWIG_AsVal_int(obj0, &val1);
49609 if (!SWIG_IsOK(ecode1)) {
49610 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49611 }
49612 arg1 = static_cast< int >(val1);
49613 ecode2 = SWIG_AsVal_int(obj1, &val2);
49614 if (!SWIG_IsOK(ecode2)) {
49615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49616 }
49617 arg2 = static_cast< int >(val2);
49618 ecode3 = SWIG_AsVal_int(obj2, &val3);
49619 if (!SWIG_IsOK(ecode3)) {
49620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
49621 }
49622 arg3 = static_cast< int >(val3);
49623 ecode4 = SWIG_AsVal_int(obj3, &val4);
49624 if (!SWIG_IsOK(ecode4)) {
49625 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
49626 }
49627 arg4 = static_cast< int >(val4);
49628 ecode5 = SWIG_AsVal_int(obj4, &val5);
49629 if (!SWIG_IsOK(ecode5)) {
49630 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49631 }
49632 arg5 = static_cast< int >(val5);
49633 if (obj5) {
49634 arg6 = obj5;
49635 }
49636 {
49637 PyThreadState* __tstate = wxPyBeginAllowThreads();
49638 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
49639 wxPyEndAllowThreads(__tstate);
49640 if (PyErr_Occurred()) SWIG_fail;
49641 }
49642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49643 return resultobj;
49644 fail:
49645 return NULL;
49646 }
49647
49648
49649 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49650 PyObject *resultobj = 0;
49651 wxSizer *arg1 = (wxSizer *) 0 ;
49652 int arg2 ;
49653 int arg3 ;
49654 int arg4 ;
49655 PyObject *arg5 = (PyObject *) NULL ;
49656 wxSizerItem *result = 0 ;
49657 int res1 = 0 ;
49658 int val2 ;
49659 int ecode2 = 0 ;
49660 int val3 ;
49661 int ecode3 = 0 ;
49662 int val4 ;
49663 int ecode4 = 0 ;
49664 PyObject * obj0 = 0 ;
49665 PyObject * obj1 = 0 ;
49666 PyObject * obj2 = 0 ;
49667 PyObject * obj3 = 0 ;
49668 PyObject * obj4 = 0 ;
49669 char * kwnames[] = {
49670 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49671 };
49672
49673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49674 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49675 if (!SWIG_IsOK(res1)) {
49676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49677 }
49678 ecode2 = SWIG_AsVal_int(obj1, &val2);
49679 if (!SWIG_IsOK(ecode2)) {
49680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
49681 }
49682 arg2 = static_cast< int >(val2);
49683 ecode3 = SWIG_AsVal_int(obj2, &val3);
49684 if (!SWIG_IsOK(ecode3)) {
49685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
49686 }
49687 arg3 = static_cast< int >(val3);
49688 ecode4 = SWIG_AsVal_int(obj3, &val4);
49689 if (!SWIG_IsOK(ecode4)) {
49690 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49691 }
49692 arg4 = static_cast< int >(val4);
49693 if (obj4) {
49694 arg5 = obj4;
49695 }
49696 {
49697 PyThreadState* __tstate = wxPyBeginAllowThreads();
49698 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49699 wxPyEndAllowThreads(__tstate);
49700 if (PyErr_Occurred()) SWIG_fail;
49701 }
49702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49703 return resultobj;
49704 fail:
49705 return NULL;
49706 }
49707
49708
49709 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49710 PyObject *resultobj = 0;
49711 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49712 void *argp1 = 0 ;
49713 int res1 = 0 ;
49714 PyObject *swig_obj[1] ;
49715
49716 if (!args) SWIG_fail;
49717 swig_obj[0] = args;
49718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49719 if (!SWIG_IsOK(res1)) {
49720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49721 }
49722 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49723 {
49724 PyThreadState* __tstate = wxPyBeginAllowThreads();
49725 (arg1)->DeleteWindows();
49726 wxPyEndAllowThreads(__tstate);
49727 if (PyErr_Occurred()) SWIG_fail;
49728 }
49729 resultobj = SWIG_Py_Void();
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49737 PyObject *resultobj = 0;
49738 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49739 void *argp1 = 0 ;
49740 int res1 = 0 ;
49741 PyObject *swig_obj[1] ;
49742
49743 if (!args) SWIG_fail;
49744 swig_obj[0] = args;
49745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49746 if (!SWIG_IsOK(res1)) {
49747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49748 }
49749 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49750 {
49751 PyThreadState* __tstate = wxPyBeginAllowThreads();
49752 (arg1)->DetachSizer();
49753 wxPyEndAllowThreads(__tstate);
49754 if (PyErr_Occurred()) SWIG_fail;
49755 }
49756 resultobj = SWIG_Py_Void();
49757 return resultobj;
49758 fail:
49759 return NULL;
49760 }
49761
49762
49763 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49764 PyObject *resultobj = 0;
49765 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49766 wxSize result;
49767 void *argp1 = 0 ;
49768 int res1 = 0 ;
49769 PyObject *swig_obj[1] ;
49770
49771 if (!args) SWIG_fail;
49772 swig_obj[0] = args;
49773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49774 if (!SWIG_IsOK(res1)) {
49775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49776 }
49777 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49778 {
49779 PyThreadState* __tstate = wxPyBeginAllowThreads();
49780 result = (arg1)->GetSize();
49781 wxPyEndAllowThreads(__tstate);
49782 if (PyErr_Occurred()) SWIG_fail;
49783 }
49784 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49785 return resultobj;
49786 fail:
49787 return NULL;
49788 }
49789
49790
49791 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49792 PyObject *resultobj = 0;
49793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49794 wxSize result;
49795 void *argp1 = 0 ;
49796 int res1 = 0 ;
49797 PyObject *swig_obj[1] ;
49798
49799 if (!args) SWIG_fail;
49800 swig_obj[0] = args;
49801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49802 if (!SWIG_IsOK(res1)) {
49803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49804 }
49805 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49806 {
49807 PyThreadState* __tstate = wxPyBeginAllowThreads();
49808 result = (arg1)->CalcMin();
49809 wxPyEndAllowThreads(__tstate);
49810 if (PyErr_Occurred()) SWIG_fail;
49811 }
49812 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49813 return resultobj;
49814 fail:
49815 return NULL;
49816 }
49817
49818
49819 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49820 PyObject *resultobj = 0;
49821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49822 wxPoint *arg2 = 0 ;
49823 wxSize *arg3 = 0 ;
49824 void *argp1 = 0 ;
49825 int res1 = 0 ;
49826 wxPoint temp2 ;
49827 wxSize temp3 ;
49828 PyObject * obj0 = 0 ;
49829 PyObject * obj1 = 0 ;
49830 PyObject * obj2 = 0 ;
49831 char * kwnames[] = {
49832 (char *) "self",(char *) "pos",(char *) "size", NULL
49833 };
49834
49835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49837 if (!SWIG_IsOK(res1)) {
49838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49839 }
49840 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49841 {
49842 arg2 = &temp2;
49843 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
49844 }
49845 {
49846 arg3 = &temp3;
49847 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
49848 }
49849 {
49850 PyThreadState* __tstate = wxPyBeginAllowThreads();
49851 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
49852 wxPyEndAllowThreads(__tstate);
49853 if (PyErr_Occurred()) SWIG_fail;
49854 }
49855 resultobj = SWIG_Py_Void();
49856 return resultobj;
49857 fail:
49858 return NULL;
49859 }
49860
49861
49862 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49863 PyObject *resultobj = 0;
49864 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49865 wxSize result;
49866 void *argp1 = 0 ;
49867 int res1 = 0 ;
49868 PyObject *swig_obj[1] ;
49869
49870 if (!args) SWIG_fail;
49871 swig_obj[0] = args;
49872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49873 if (!SWIG_IsOK(res1)) {
49874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49875 }
49876 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49877 {
49878 PyThreadState* __tstate = wxPyBeginAllowThreads();
49879 result = (arg1)->GetMinSize();
49880 wxPyEndAllowThreads(__tstate);
49881 if (PyErr_Occurred()) SWIG_fail;
49882 }
49883 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49884 return resultobj;
49885 fail:
49886 return NULL;
49887 }
49888
49889
49890 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49891 PyObject *resultobj = 0;
49892 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49893 wxSize result;
49894 void *argp1 = 0 ;
49895 int res1 = 0 ;
49896 PyObject *swig_obj[1] ;
49897
49898 if (!args) SWIG_fail;
49899 swig_obj[0] = args;
49900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49901 if (!SWIG_IsOK(res1)) {
49902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
49903 }
49904 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49905 {
49906 PyThreadState* __tstate = wxPyBeginAllowThreads();
49907 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
49908 wxPyEndAllowThreads(__tstate);
49909 if (PyErr_Occurred()) SWIG_fail;
49910 }
49911 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49912 return resultobj;
49913 fail:
49914 return NULL;
49915 }
49916
49917
49918 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49919 PyObject *resultobj = 0;
49920 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49921 int arg2 ;
49922 int arg3 ;
49923 void *argp1 = 0 ;
49924 int res1 = 0 ;
49925 int val2 ;
49926 int ecode2 = 0 ;
49927 int val3 ;
49928 int ecode3 = 0 ;
49929 PyObject * obj0 = 0 ;
49930 PyObject * obj1 = 0 ;
49931 PyObject * obj2 = 0 ;
49932 char * kwnames[] = {
49933 (char *) "self",(char *) "x",(char *) "y", NULL
49934 };
49935
49936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49938 if (!SWIG_IsOK(res1)) {
49939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49940 }
49941 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49942 ecode2 = SWIG_AsVal_int(obj1, &val2);
49943 if (!SWIG_IsOK(ecode2)) {
49944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
49945 }
49946 arg2 = static_cast< int >(val2);
49947 ecode3 = SWIG_AsVal_int(obj2, &val3);
49948 if (!SWIG_IsOK(ecode3)) {
49949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
49950 }
49951 arg3 = static_cast< int >(val3);
49952 {
49953 PyThreadState* __tstate = wxPyBeginAllowThreads();
49954 (arg1)->SetInitSize(arg2,arg3);
49955 wxPyEndAllowThreads(__tstate);
49956 if (PyErr_Occurred()) SWIG_fail;
49957 }
49958 resultobj = SWIG_Py_Void();
49959 return resultobj;
49960 fail:
49961 return NULL;
49962 }
49963
49964
49965 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49966 PyObject *resultobj = 0;
49967 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49968 int arg2 ;
49969 int arg3 ;
49970 void *argp1 = 0 ;
49971 int res1 = 0 ;
49972 int val2 ;
49973 int ecode2 = 0 ;
49974 int val3 ;
49975 int ecode3 = 0 ;
49976 PyObject * obj0 = 0 ;
49977 PyObject * obj1 = 0 ;
49978 PyObject * obj2 = 0 ;
49979 char * kwnames[] = {
49980 (char *) "self",(char *) "width",(char *) "height", NULL
49981 };
49982
49983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49985 if (!SWIG_IsOK(res1)) {
49986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49987 }
49988 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49989 ecode2 = SWIG_AsVal_int(obj1, &val2);
49990 if (!SWIG_IsOK(ecode2)) {
49991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
49992 }
49993 arg2 = static_cast< int >(val2);
49994 ecode3 = SWIG_AsVal_int(obj2, &val3);
49995 if (!SWIG_IsOK(ecode3)) {
49996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
49997 }
49998 arg3 = static_cast< int >(val3);
49999 {
50000 PyThreadState* __tstate = wxPyBeginAllowThreads();
50001 (arg1)->SetRatio(arg2,arg3);
50002 wxPyEndAllowThreads(__tstate);
50003 if (PyErr_Occurred()) SWIG_fail;
50004 }
50005 resultobj = SWIG_Py_Void();
50006 return resultobj;
50007 fail:
50008 return NULL;
50009 }
50010
50011
50012 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50013 PyObject *resultobj = 0;
50014 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50015 wxSize *arg2 = 0 ;
50016 void *argp1 = 0 ;
50017 int res1 = 0 ;
50018 wxSize temp2 ;
50019 PyObject * obj0 = 0 ;
50020 PyObject * obj1 = 0 ;
50021 char * kwnames[] = {
50022 (char *) "self",(char *) "size", NULL
50023 };
50024
50025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) 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_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50029 }
50030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50031 {
50032 arg2 = &temp2;
50033 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50034 }
50035 {
50036 PyThreadState* __tstate = wxPyBeginAllowThreads();
50037 (arg1)->SetRatio((wxSize const &)*arg2);
50038 wxPyEndAllowThreads(__tstate);
50039 if (PyErr_Occurred()) SWIG_fail;
50040 }
50041 resultobj = SWIG_Py_Void();
50042 return resultobj;
50043 fail:
50044 return NULL;
50045 }
50046
50047
50048 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50049 PyObject *resultobj = 0;
50050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50051 float arg2 ;
50052 void *argp1 = 0 ;
50053 int res1 = 0 ;
50054 float val2 ;
50055 int ecode2 = 0 ;
50056 PyObject * obj0 = 0 ;
50057 PyObject * obj1 = 0 ;
50058 char * kwnames[] = {
50059 (char *) "self",(char *) "ratio", NULL
50060 };
50061
50062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50064 if (!SWIG_IsOK(res1)) {
50065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50066 }
50067 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50068 ecode2 = SWIG_AsVal_float(obj1, &val2);
50069 if (!SWIG_IsOK(ecode2)) {
50070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50071 }
50072 arg2 = static_cast< float >(val2);
50073 {
50074 PyThreadState* __tstate = wxPyBeginAllowThreads();
50075 (arg1)->SetRatio(arg2);
50076 wxPyEndAllowThreads(__tstate);
50077 if (PyErr_Occurred()) SWIG_fail;
50078 }
50079 resultobj = SWIG_Py_Void();
50080 return resultobj;
50081 fail:
50082 return NULL;
50083 }
50084
50085
50086 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50087 PyObject *resultobj = 0;
50088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50089 float result;
50090 void *argp1 = 0 ;
50091 int res1 = 0 ;
50092 PyObject *swig_obj[1] ;
50093
50094 if (!args) SWIG_fail;
50095 swig_obj[0] = args;
50096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50097 if (!SWIG_IsOK(res1)) {
50098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50099 }
50100 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50101 {
50102 PyThreadState* __tstate = wxPyBeginAllowThreads();
50103 result = (float)(arg1)->GetRatio();
50104 wxPyEndAllowThreads(__tstate);
50105 if (PyErr_Occurred()) SWIG_fail;
50106 }
50107 resultobj = SWIG_From_float(static_cast< float >(result));
50108 return resultobj;
50109 fail:
50110 return NULL;
50111 }
50112
50113
50114 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50115 PyObject *resultobj = 0;
50116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50117 wxRect result;
50118 void *argp1 = 0 ;
50119 int res1 = 0 ;
50120 PyObject *swig_obj[1] ;
50121
50122 if (!args) SWIG_fail;
50123 swig_obj[0] = args;
50124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50125 if (!SWIG_IsOK(res1)) {
50126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50127 }
50128 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50129 {
50130 PyThreadState* __tstate = wxPyBeginAllowThreads();
50131 result = (arg1)->GetRect();
50132 wxPyEndAllowThreads(__tstate);
50133 if (PyErr_Occurred()) SWIG_fail;
50134 }
50135 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50136 return resultobj;
50137 fail:
50138 return NULL;
50139 }
50140
50141
50142 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50143 PyObject *resultobj = 0;
50144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50145 bool result;
50146 void *argp1 = 0 ;
50147 int res1 = 0 ;
50148 PyObject *swig_obj[1] ;
50149
50150 if (!args) SWIG_fail;
50151 swig_obj[0] = args;
50152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50153 if (!SWIG_IsOK(res1)) {
50154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50155 }
50156 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50157 {
50158 PyThreadState* __tstate = wxPyBeginAllowThreads();
50159 result = (bool)(arg1)->IsWindow();
50160 wxPyEndAllowThreads(__tstate);
50161 if (PyErr_Occurred()) SWIG_fail;
50162 }
50163 {
50164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50165 }
50166 return resultobj;
50167 fail:
50168 return NULL;
50169 }
50170
50171
50172 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50173 PyObject *resultobj = 0;
50174 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50175 bool result;
50176 void *argp1 = 0 ;
50177 int res1 = 0 ;
50178 PyObject *swig_obj[1] ;
50179
50180 if (!args) SWIG_fail;
50181 swig_obj[0] = args;
50182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50183 if (!SWIG_IsOK(res1)) {
50184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50185 }
50186 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50187 {
50188 PyThreadState* __tstate = wxPyBeginAllowThreads();
50189 result = (bool)(arg1)->IsSizer();
50190 wxPyEndAllowThreads(__tstate);
50191 if (PyErr_Occurred()) SWIG_fail;
50192 }
50193 {
50194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50195 }
50196 return resultobj;
50197 fail:
50198 return NULL;
50199 }
50200
50201
50202 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50203 PyObject *resultobj = 0;
50204 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50205 bool result;
50206 void *argp1 = 0 ;
50207 int res1 = 0 ;
50208 PyObject *swig_obj[1] ;
50209
50210 if (!args) SWIG_fail;
50211 swig_obj[0] = args;
50212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50213 if (!SWIG_IsOK(res1)) {
50214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50215 }
50216 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50217 {
50218 PyThreadState* __tstate = wxPyBeginAllowThreads();
50219 result = (bool)(arg1)->IsSpacer();
50220 wxPyEndAllowThreads(__tstate);
50221 if (PyErr_Occurred()) SWIG_fail;
50222 }
50223 {
50224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50225 }
50226 return resultobj;
50227 fail:
50228 return NULL;
50229 }
50230
50231
50232 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50233 PyObject *resultobj = 0;
50234 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50235 int arg2 ;
50236 void *argp1 = 0 ;
50237 int res1 = 0 ;
50238 int val2 ;
50239 int ecode2 = 0 ;
50240 PyObject * obj0 = 0 ;
50241 PyObject * obj1 = 0 ;
50242 char * kwnames[] = {
50243 (char *) "self",(char *) "proportion", NULL
50244 };
50245
50246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50248 if (!SWIG_IsOK(res1)) {
50249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50250 }
50251 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50252 ecode2 = SWIG_AsVal_int(obj1, &val2);
50253 if (!SWIG_IsOK(ecode2)) {
50254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50255 }
50256 arg2 = static_cast< int >(val2);
50257 {
50258 PyThreadState* __tstate = wxPyBeginAllowThreads();
50259 (arg1)->SetProportion(arg2);
50260 wxPyEndAllowThreads(__tstate);
50261 if (PyErr_Occurred()) SWIG_fail;
50262 }
50263 resultobj = SWIG_Py_Void();
50264 return resultobj;
50265 fail:
50266 return NULL;
50267 }
50268
50269
50270 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50271 PyObject *resultobj = 0;
50272 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50273 int result;
50274 void *argp1 = 0 ;
50275 int res1 = 0 ;
50276 PyObject *swig_obj[1] ;
50277
50278 if (!args) SWIG_fail;
50279 swig_obj[0] = args;
50280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50281 if (!SWIG_IsOK(res1)) {
50282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50283 }
50284 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50285 {
50286 PyThreadState* __tstate = wxPyBeginAllowThreads();
50287 result = (int)(arg1)->GetProportion();
50288 wxPyEndAllowThreads(__tstate);
50289 if (PyErr_Occurred()) SWIG_fail;
50290 }
50291 resultobj = SWIG_From_int(static_cast< int >(result));
50292 return resultobj;
50293 fail:
50294 return NULL;
50295 }
50296
50297
50298 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50299 PyObject *resultobj = 0;
50300 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50301 int arg2 ;
50302 void *argp1 = 0 ;
50303 int res1 = 0 ;
50304 int val2 ;
50305 int ecode2 = 0 ;
50306 PyObject * obj0 = 0 ;
50307 PyObject * obj1 = 0 ;
50308 char * kwnames[] = {
50309 (char *) "self",(char *) "flag", NULL
50310 };
50311
50312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50314 if (!SWIG_IsOK(res1)) {
50315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50316 }
50317 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50318 ecode2 = SWIG_AsVal_int(obj1, &val2);
50319 if (!SWIG_IsOK(ecode2)) {
50320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50321 }
50322 arg2 = static_cast< int >(val2);
50323 {
50324 PyThreadState* __tstate = wxPyBeginAllowThreads();
50325 (arg1)->SetFlag(arg2);
50326 wxPyEndAllowThreads(__tstate);
50327 if (PyErr_Occurred()) SWIG_fail;
50328 }
50329 resultobj = SWIG_Py_Void();
50330 return resultobj;
50331 fail:
50332 return NULL;
50333 }
50334
50335
50336 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50337 PyObject *resultobj = 0;
50338 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50339 int result;
50340 void *argp1 = 0 ;
50341 int res1 = 0 ;
50342 PyObject *swig_obj[1] ;
50343
50344 if (!args) SWIG_fail;
50345 swig_obj[0] = args;
50346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50347 if (!SWIG_IsOK(res1)) {
50348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50349 }
50350 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50351 {
50352 PyThreadState* __tstate = wxPyBeginAllowThreads();
50353 result = (int)(arg1)->GetFlag();
50354 wxPyEndAllowThreads(__tstate);
50355 if (PyErr_Occurred()) SWIG_fail;
50356 }
50357 resultobj = SWIG_From_int(static_cast< int >(result));
50358 return resultobj;
50359 fail:
50360 return NULL;
50361 }
50362
50363
50364 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50365 PyObject *resultobj = 0;
50366 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50367 int arg2 ;
50368 void *argp1 = 0 ;
50369 int res1 = 0 ;
50370 int val2 ;
50371 int ecode2 = 0 ;
50372 PyObject * obj0 = 0 ;
50373 PyObject * obj1 = 0 ;
50374 char * kwnames[] = {
50375 (char *) "self",(char *) "border", NULL
50376 };
50377
50378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50380 if (!SWIG_IsOK(res1)) {
50381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50382 }
50383 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50384 ecode2 = SWIG_AsVal_int(obj1, &val2);
50385 if (!SWIG_IsOK(ecode2)) {
50386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50387 }
50388 arg2 = static_cast< int >(val2);
50389 {
50390 PyThreadState* __tstate = wxPyBeginAllowThreads();
50391 (arg1)->SetBorder(arg2);
50392 wxPyEndAllowThreads(__tstate);
50393 if (PyErr_Occurred()) SWIG_fail;
50394 }
50395 resultobj = SWIG_Py_Void();
50396 return resultobj;
50397 fail:
50398 return NULL;
50399 }
50400
50401
50402 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50403 PyObject *resultobj = 0;
50404 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50405 int result;
50406 void *argp1 = 0 ;
50407 int res1 = 0 ;
50408 PyObject *swig_obj[1] ;
50409
50410 if (!args) SWIG_fail;
50411 swig_obj[0] = args;
50412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50413 if (!SWIG_IsOK(res1)) {
50414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50415 }
50416 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50417 {
50418 PyThreadState* __tstate = wxPyBeginAllowThreads();
50419 result = (int)(arg1)->GetBorder();
50420 wxPyEndAllowThreads(__tstate);
50421 if (PyErr_Occurred()) SWIG_fail;
50422 }
50423 resultobj = SWIG_From_int(static_cast< int >(result));
50424 return resultobj;
50425 fail:
50426 return NULL;
50427 }
50428
50429
50430 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50431 PyObject *resultobj = 0;
50432 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50433 wxWindow *result = 0 ;
50434 void *argp1 = 0 ;
50435 int res1 = 0 ;
50436 PyObject *swig_obj[1] ;
50437
50438 if (!args) SWIG_fail;
50439 swig_obj[0] = args;
50440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50441 if (!SWIG_IsOK(res1)) {
50442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50443 }
50444 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50445 {
50446 PyThreadState* __tstate = wxPyBeginAllowThreads();
50447 result = (wxWindow *)(arg1)->GetWindow();
50448 wxPyEndAllowThreads(__tstate);
50449 if (PyErr_Occurred()) SWIG_fail;
50450 }
50451 {
50452 resultobj = wxPyMake_wxObject(result, 0);
50453 }
50454 return resultobj;
50455 fail:
50456 return NULL;
50457 }
50458
50459
50460 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50461 PyObject *resultobj = 0;
50462 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50463 wxWindow *arg2 = (wxWindow *) 0 ;
50464 void *argp1 = 0 ;
50465 int res1 = 0 ;
50466 void *argp2 = 0 ;
50467 int res2 = 0 ;
50468 PyObject * obj0 = 0 ;
50469 PyObject * obj1 = 0 ;
50470 char * kwnames[] = {
50471 (char *) "self",(char *) "window", NULL
50472 };
50473
50474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50476 if (!SWIG_IsOK(res1)) {
50477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50478 }
50479 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50481 if (!SWIG_IsOK(res2)) {
50482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50483 }
50484 arg2 = reinterpret_cast< wxWindow * >(argp2);
50485 {
50486 PyThreadState* __tstate = wxPyBeginAllowThreads();
50487 (arg1)->SetWindow(arg2);
50488 wxPyEndAllowThreads(__tstate);
50489 if (PyErr_Occurred()) SWIG_fail;
50490 }
50491 resultobj = SWIG_Py_Void();
50492 return resultobj;
50493 fail:
50494 return NULL;
50495 }
50496
50497
50498 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50499 PyObject *resultobj = 0;
50500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50501 wxSizer *result = 0 ;
50502 void *argp1 = 0 ;
50503 int res1 = 0 ;
50504 PyObject *swig_obj[1] ;
50505
50506 if (!args) SWIG_fail;
50507 swig_obj[0] = args;
50508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50509 if (!SWIG_IsOK(res1)) {
50510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50511 }
50512 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50513 {
50514 PyThreadState* __tstate = wxPyBeginAllowThreads();
50515 result = (wxSizer *)(arg1)->GetSizer();
50516 wxPyEndAllowThreads(__tstate);
50517 if (PyErr_Occurred()) SWIG_fail;
50518 }
50519 {
50520 resultobj = wxPyMake_wxObject(result, (bool)0);
50521 }
50522 return resultobj;
50523 fail:
50524 return NULL;
50525 }
50526
50527
50528 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50529 PyObject *resultobj = 0;
50530 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50531 wxSizer *arg2 = (wxSizer *) 0 ;
50532 void *argp1 = 0 ;
50533 int res1 = 0 ;
50534 int res2 = 0 ;
50535 PyObject * obj0 = 0 ;
50536 PyObject * obj1 = 0 ;
50537 char * kwnames[] = {
50538 (char *) "self",(char *) "sizer", NULL
50539 };
50540
50541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50543 if (!SWIG_IsOK(res1)) {
50544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50545 }
50546 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50547 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50548 if (!SWIG_IsOK(res2)) {
50549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50550 }
50551 {
50552 PyThreadState* __tstate = wxPyBeginAllowThreads();
50553 (arg1)->SetSizer(arg2);
50554 wxPyEndAllowThreads(__tstate);
50555 if (PyErr_Occurred()) SWIG_fail;
50556 }
50557 resultobj = SWIG_Py_Void();
50558 return resultobj;
50559 fail:
50560 return NULL;
50561 }
50562
50563
50564 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50565 PyObject *resultobj = 0;
50566 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50567 wxSize result;
50568 void *argp1 = 0 ;
50569 int res1 = 0 ;
50570 PyObject *swig_obj[1] ;
50571
50572 if (!args) SWIG_fail;
50573 swig_obj[0] = args;
50574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50575 if (!SWIG_IsOK(res1)) {
50576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50577 }
50578 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50579 {
50580 PyThreadState* __tstate = wxPyBeginAllowThreads();
50581 result = (arg1)->GetSpacer();
50582 wxPyEndAllowThreads(__tstate);
50583 if (PyErr_Occurred()) SWIG_fail;
50584 }
50585 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50586 return resultobj;
50587 fail:
50588 return NULL;
50589 }
50590
50591
50592 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50593 PyObject *resultobj = 0;
50594 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50595 wxSize *arg2 = 0 ;
50596 void *argp1 = 0 ;
50597 int res1 = 0 ;
50598 wxSize temp2 ;
50599 PyObject * obj0 = 0 ;
50600 PyObject * obj1 = 0 ;
50601 char * kwnames[] = {
50602 (char *) "self",(char *) "size", NULL
50603 };
50604
50605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50607 if (!SWIG_IsOK(res1)) {
50608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50609 }
50610 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50611 {
50612 arg2 = &temp2;
50613 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50614 }
50615 {
50616 PyThreadState* __tstate = wxPyBeginAllowThreads();
50617 (arg1)->SetSpacer((wxSize const &)*arg2);
50618 wxPyEndAllowThreads(__tstate);
50619 if (PyErr_Occurred()) SWIG_fail;
50620 }
50621 resultobj = SWIG_Py_Void();
50622 return resultobj;
50623 fail:
50624 return NULL;
50625 }
50626
50627
50628 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50629 PyObject *resultobj = 0;
50630 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50631 bool arg2 ;
50632 void *argp1 = 0 ;
50633 int res1 = 0 ;
50634 bool val2 ;
50635 int ecode2 = 0 ;
50636 PyObject * obj0 = 0 ;
50637 PyObject * obj1 = 0 ;
50638 char * kwnames[] = {
50639 (char *) "self",(char *) "show", NULL
50640 };
50641
50642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
50643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50646 }
50647 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50648 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50649 if (!SWIG_IsOK(ecode2)) {
50650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
50651 }
50652 arg2 = static_cast< bool >(val2);
50653 {
50654 PyThreadState* __tstate = wxPyBeginAllowThreads();
50655 (arg1)->Show(arg2);
50656 wxPyEndAllowThreads(__tstate);
50657 if (PyErr_Occurred()) SWIG_fail;
50658 }
50659 resultobj = SWIG_Py_Void();
50660 return resultobj;
50661 fail:
50662 return NULL;
50663 }
50664
50665
50666 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50667 PyObject *resultobj = 0;
50668 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50669 bool result;
50670 void *argp1 = 0 ;
50671 int res1 = 0 ;
50672 PyObject *swig_obj[1] ;
50673
50674 if (!args) SWIG_fail;
50675 swig_obj[0] = args;
50676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50677 if (!SWIG_IsOK(res1)) {
50678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50679 }
50680 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50681 {
50682 PyThreadState* __tstate = wxPyBeginAllowThreads();
50683 result = (bool)(arg1)->IsShown();
50684 wxPyEndAllowThreads(__tstate);
50685 if (PyErr_Occurred()) SWIG_fail;
50686 }
50687 {
50688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50689 }
50690 return resultobj;
50691 fail:
50692 return NULL;
50693 }
50694
50695
50696 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50697 PyObject *resultobj = 0;
50698 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50699 wxPoint result;
50700 void *argp1 = 0 ;
50701 int res1 = 0 ;
50702 PyObject *swig_obj[1] ;
50703
50704 if (!args) SWIG_fail;
50705 swig_obj[0] = args;
50706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50707 if (!SWIG_IsOK(res1)) {
50708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50709 }
50710 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50711 {
50712 PyThreadState* __tstate = wxPyBeginAllowThreads();
50713 result = (arg1)->GetPosition();
50714 wxPyEndAllowThreads(__tstate);
50715 if (PyErr_Occurred()) SWIG_fail;
50716 }
50717 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50718 return resultobj;
50719 fail:
50720 return NULL;
50721 }
50722
50723
50724 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50725 PyObject *resultobj = 0;
50726 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50727 PyObject *result = 0 ;
50728 void *argp1 = 0 ;
50729 int res1 = 0 ;
50730 PyObject *swig_obj[1] ;
50731
50732 if (!args) SWIG_fail;
50733 swig_obj[0] = args;
50734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50735 if (!SWIG_IsOK(res1)) {
50736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50737 }
50738 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50739 {
50740 PyThreadState* __tstate = wxPyBeginAllowThreads();
50741 result = (PyObject *)wxSizerItem_GetUserData(arg1);
50742 wxPyEndAllowThreads(__tstate);
50743 if (PyErr_Occurred()) SWIG_fail;
50744 }
50745 resultobj = result;
50746 return resultobj;
50747 fail:
50748 return NULL;
50749 }
50750
50751
50752 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50753 PyObject *resultobj = 0;
50754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50755 PyObject *arg2 = (PyObject *) 0 ;
50756 void *argp1 = 0 ;
50757 int res1 = 0 ;
50758 PyObject * obj0 = 0 ;
50759 PyObject * obj1 = 0 ;
50760 char * kwnames[] = {
50761 (char *) "self",(char *) "userData", NULL
50762 };
50763
50764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
50765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50766 if (!SWIG_IsOK(res1)) {
50767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50768 }
50769 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50770 arg2 = obj1;
50771 {
50772 PyThreadState* __tstate = wxPyBeginAllowThreads();
50773 wxSizerItem_SetUserData(arg1,arg2);
50774 wxPyEndAllowThreads(__tstate);
50775 if (PyErr_Occurred()) SWIG_fail;
50776 }
50777 resultobj = SWIG_Py_Void();
50778 return resultobj;
50779 fail:
50780 return NULL;
50781 }
50782
50783
50784 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50785 PyObject *obj;
50786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50787 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
50788 return SWIG_Py_Void();
50789 }
50790
50791 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50792 return SWIG_Python_InitShadowInstance(args);
50793 }
50794
50795 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50796 PyObject *resultobj = 0;
50797 wxSizer *arg1 = (wxSizer *) 0 ;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 PyObject *swig_obj[1] ;
50801
50802 if (!args) SWIG_fail;
50803 swig_obj[0] = args;
50804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50805 if (!SWIG_IsOK(res1)) {
50806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50807 }
50808 arg1 = reinterpret_cast< wxSizer * >(argp1);
50809 {
50810 PyThreadState* __tstate = wxPyBeginAllowThreads();
50811 delete arg1;
50812
50813 wxPyEndAllowThreads(__tstate);
50814 if (PyErr_Occurred()) SWIG_fail;
50815 }
50816 resultobj = SWIG_Py_Void();
50817 return resultobj;
50818 fail:
50819 return NULL;
50820 }
50821
50822
50823 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50824 PyObject *resultobj = 0;
50825 wxSizer *arg1 = (wxSizer *) 0 ;
50826 PyObject *arg2 = (PyObject *) 0 ;
50827 void *argp1 = 0 ;
50828 int res1 = 0 ;
50829 PyObject * obj0 = 0 ;
50830 PyObject * obj1 = 0 ;
50831 char * kwnames[] = {
50832 (char *) "self",(char *) "_self", NULL
50833 };
50834
50835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
50836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50837 if (!SWIG_IsOK(res1)) {
50838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
50839 }
50840 arg1 = reinterpret_cast< wxSizer * >(argp1);
50841 arg2 = obj1;
50842 {
50843 PyThreadState* __tstate = wxPyBeginAllowThreads();
50844 wxSizer__setOORInfo(arg1,arg2);
50845 wxPyEndAllowThreads(__tstate);
50846 if (PyErr_Occurred()) SWIG_fail;
50847 }
50848 resultobj = SWIG_Py_Void();
50849 return resultobj;
50850 fail:
50851 return NULL;
50852 }
50853
50854
50855 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50856 PyObject *resultobj = 0;
50857 wxSizer *arg1 = (wxSizer *) 0 ;
50858 PyObject *arg2 = (PyObject *) 0 ;
50859 int arg3 = (int) 0 ;
50860 int arg4 = (int) 0 ;
50861 int arg5 = (int) 0 ;
50862 PyObject *arg6 = (PyObject *) NULL ;
50863 wxSizerItem *result = 0 ;
50864 void *argp1 = 0 ;
50865 int res1 = 0 ;
50866 int val3 ;
50867 int ecode3 = 0 ;
50868 int val4 ;
50869 int ecode4 = 0 ;
50870 int val5 ;
50871 int ecode5 = 0 ;
50872 PyObject * obj0 = 0 ;
50873 PyObject * obj1 = 0 ;
50874 PyObject * obj2 = 0 ;
50875 PyObject * obj3 = 0 ;
50876 PyObject * obj4 = 0 ;
50877 PyObject * obj5 = 0 ;
50878 char * kwnames[] = {
50879 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50880 };
50881
50882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50884 if (!SWIG_IsOK(res1)) {
50885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
50886 }
50887 arg1 = reinterpret_cast< wxSizer * >(argp1);
50888 arg2 = obj1;
50889 if (obj2) {
50890 ecode3 = SWIG_AsVal_int(obj2, &val3);
50891 if (!SWIG_IsOK(ecode3)) {
50892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
50893 }
50894 arg3 = static_cast< int >(val3);
50895 }
50896 if (obj3) {
50897 ecode4 = SWIG_AsVal_int(obj3, &val4);
50898 if (!SWIG_IsOK(ecode4)) {
50899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
50900 }
50901 arg4 = static_cast< int >(val4);
50902 }
50903 if (obj4) {
50904 ecode5 = SWIG_AsVal_int(obj4, &val5);
50905 if (!SWIG_IsOK(ecode5)) {
50906 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
50907 }
50908 arg5 = static_cast< int >(val5);
50909 }
50910 if (obj5) {
50911 arg6 = obj5;
50912 }
50913 {
50914 PyThreadState* __tstate = wxPyBeginAllowThreads();
50915 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
50916 wxPyEndAllowThreads(__tstate);
50917 if (PyErr_Occurred()) SWIG_fail;
50918 }
50919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50920 return resultobj;
50921 fail:
50922 return NULL;
50923 }
50924
50925
50926 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50927 PyObject *resultobj = 0;
50928 wxSizer *arg1 = (wxSizer *) 0 ;
50929 PyObject *arg2 = (PyObject *) 0 ;
50930 wxSizerFlags *arg3 = 0 ;
50931 wxSizerItem *result = 0 ;
50932 void *argp1 = 0 ;
50933 int res1 = 0 ;
50934 void *argp3 = 0 ;
50935 int res3 = 0 ;
50936 PyObject * obj0 = 0 ;
50937 PyObject * obj1 = 0 ;
50938 PyObject * obj2 = 0 ;
50939 char * kwnames[] = {
50940 (char *) "self",(char *) "item",(char *) "flags", NULL
50941 };
50942
50943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50945 if (!SWIG_IsOK(res1)) {
50946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
50947 }
50948 arg1 = reinterpret_cast< wxSizer * >(argp1);
50949 arg2 = obj1;
50950 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
50951 if (!SWIG_IsOK(res3)) {
50952 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
50953 }
50954 if (!argp3) {
50955 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
50956 }
50957 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
50958 {
50959 PyThreadState* __tstate = wxPyBeginAllowThreads();
50960 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
50961 wxPyEndAllowThreads(__tstate);
50962 if (PyErr_Occurred()) SWIG_fail;
50963 }
50964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50965 return resultobj;
50966 fail:
50967 return NULL;
50968 }
50969
50970
50971 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50972 PyObject *resultobj = 0;
50973 wxSizer *arg1 = (wxSizer *) 0 ;
50974 int arg2 ;
50975 PyObject *arg3 = (PyObject *) 0 ;
50976 int arg4 = (int) 0 ;
50977 int arg5 = (int) 0 ;
50978 int arg6 = (int) 0 ;
50979 PyObject *arg7 = (PyObject *) NULL ;
50980 wxSizerItem *result = 0 ;
50981 void *argp1 = 0 ;
50982 int res1 = 0 ;
50983 int val2 ;
50984 int ecode2 = 0 ;
50985 int val4 ;
50986 int ecode4 = 0 ;
50987 int val5 ;
50988 int ecode5 = 0 ;
50989 int val6 ;
50990 int ecode6 = 0 ;
50991 PyObject * obj0 = 0 ;
50992 PyObject * obj1 = 0 ;
50993 PyObject * obj2 = 0 ;
50994 PyObject * obj3 = 0 ;
50995 PyObject * obj4 = 0 ;
50996 PyObject * obj5 = 0 ;
50997 PyObject * obj6 = 0 ;
50998 char * kwnames[] = {
50999 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51000 };
51001
51002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51004 if (!SWIG_IsOK(res1)) {
51005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51006 }
51007 arg1 = reinterpret_cast< wxSizer * >(argp1);
51008 ecode2 = SWIG_AsVal_int(obj1, &val2);
51009 if (!SWIG_IsOK(ecode2)) {
51010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51011 }
51012 arg2 = static_cast< int >(val2);
51013 arg3 = obj2;
51014 if (obj3) {
51015 ecode4 = SWIG_AsVal_int(obj3, &val4);
51016 if (!SWIG_IsOK(ecode4)) {
51017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51018 }
51019 arg4 = static_cast< int >(val4);
51020 }
51021 if (obj4) {
51022 ecode5 = SWIG_AsVal_int(obj4, &val5);
51023 if (!SWIG_IsOK(ecode5)) {
51024 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51025 }
51026 arg5 = static_cast< int >(val5);
51027 }
51028 if (obj5) {
51029 ecode6 = SWIG_AsVal_int(obj5, &val6);
51030 if (!SWIG_IsOK(ecode6)) {
51031 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51032 }
51033 arg6 = static_cast< int >(val6);
51034 }
51035 if (obj6) {
51036 arg7 = obj6;
51037 }
51038 {
51039 PyThreadState* __tstate = wxPyBeginAllowThreads();
51040 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51041 wxPyEndAllowThreads(__tstate);
51042 if (PyErr_Occurred()) SWIG_fail;
51043 }
51044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51045 return resultobj;
51046 fail:
51047 return NULL;
51048 }
51049
51050
51051 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51052 PyObject *resultobj = 0;
51053 wxSizer *arg1 = (wxSizer *) 0 ;
51054 int arg2 ;
51055 PyObject *arg3 = (PyObject *) 0 ;
51056 wxSizerFlags *arg4 = 0 ;
51057 wxSizerItem *result = 0 ;
51058 void *argp1 = 0 ;
51059 int res1 = 0 ;
51060 int val2 ;
51061 int ecode2 = 0 ;
51062 void *argp4 = 0 ;
51063 int res4 = 0 ;
51064 PyObject * obj0 = 0 ;
51065 PyObject * obj1 = 0 ;
51066 PyObject * obj2 = 0 ;
51067 PyObject * obj3 = 0 ;
51068 char * kwnames[] = {
51069 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51070 };
51071
51072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51074 if (!SWIG_IsOK(res1)) {
51075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51076 }
51077 arg1 = reinterpret_cast< wxSizer * >(argp1);
51078 ecode2 = SWIG_AsVal_int(obj1, &val2);
51079 if (!SWIG_IsOK(ecode2)) {
51080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51081 }
51082 arg2 = static_cast< int >(val2);
51083 arg3 = obj2;
51084 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51085 if (!SWIG_IsOK(res4)) {
51086 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51087 }
51088 if (!argp4) {
51089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51090 }
51091 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51092 {
51093 PyThreadState* __tstate = wxPyBeginAllowThreads();
51094 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51095 wxPyEndAllowThreads(__tstate);
51096 if (PyErr_Occurred()) SWIG_fail;
51097 }
51098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51099 return resultobj;
51100 fail:
51101 return NULL;
51102 }
51103
51104
51105 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51106 PyObject *resultobj = 0;
51107 wxSizer *arg1 = (wxSizer *) 0 ;
51108 PyObject *arg2 = (PyObject *) 0 ;
51109 int arg3 = (int) 0 ;
51110 int arg4 = (int) 0 ;
51111 int arg5 = (int) 0 ;
51112 PyObject *arg6 = (PyObject *) NULL ;
51113 wxSizerItem *result = 0 ;
51114 void *argp1 = 0 ;
51115 int res1 = 0 ;
51116 int val3 ;
51117 int ecode3 = 0 ;
51118 int val4 ;
51119 int ecode4 = 0 ;
51120 int val5 ;
51121 int ecode5 = 0 ;
51122 PyObject * obj0 = 0 ;
51123 PyObject * obj1 = 0 ;
51124 PyObject * obj2 = 0 ;
51125 PyObject * obj3 = 0 ;
51126 PyObject * obj4 = 0 ;
51127 PyObject * obj5 = 0 ;
51128 char * kwnames[] = {
51129 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51130 };
51131
51132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51134 if (!SWIG_IsOK(res1)) {
51135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51136 }
51137 arg1 = reinterpret_cast< wxSizer * >(argp1);
51138 arg2 = obj1;
51139 if (obj2) {
51140 ecode3 = SWIG_AsVal_int(obj2, &val3);
51141 if (!SWIG_IsOK(ecode3)) {
51142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51143 }
51144 arg3 = static_cast< int >(val3);
51145 }
51146 if (obj3) {
51147 ecode4 = SWIG_AsVal_int(obj3, &val4);
51148 if (!SWIG_IsOK(ecode4)) {
51149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51150 }
51151 arg4 = static_cast< int >(val4);
51152 }
51153 if (obj4) {
51154 ecode5 = SWIG_AsVal_int(obj4, &val5);
51155 if (!SWIG_IsOK(ecode5)) {
51156 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51157 }
51158 arg5 = static_cast< int >(val5);
51159 }
51160 if (obj5) {
51161 arg6 = obj5;
51162 }
51163 {
51164 PyThreadState* __tstate = wxPyBeginAllowThreads();
51165 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51166 wxPyEndAllowThreads(__tstate);
51167 if (PyErr_Occurred()) SWIG_fail;
51168 }
51169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51170 return resultobj;
51171 fail:
51172 return NULL;
51173 }
51174
51175
51176 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51177 PyObject *resultobj = 0;
51178 wxSizer *arg1 = (wxSizer *) 0 ;
51179 PyObject *arg2 = (PyObject *) 0 ;
51180 wxSizerFlags *arg3 = 0 ;
51181 wxSizerItem *result = 0 ;
51182 void *argp1 = 0 ;
51183 int res1 = 0 ;
51184 void *argp3 = 0 ;
51185 int res3 = 0 ;
51186 PyObject * obj0 = 0 ;
51187 PyObject * obj1 = 0 ;
51188 PyObject * obj2 = 0 ;
51189 char * kwnames[] = {
51190 (char *) "self",(char *) "item",(char *) "flags", NULL
51191 };
51192
51193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51195 if (!SWIG_IsOK(res1)) {
51196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51197 }
51198 arg1 = reinterpret_cast< wxSizer * >(argp1);
51199 arg2 = obj1;
51200 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51201 if (!SWIG_IsOK(res3)) {
51202 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51203 }
51204 if (!argp3) {
51205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51206 }
51207 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51208 {
51209 PyThreadState* __tstate = wxPyBeginAllowThreads();
51210 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51211 wxPyEndAllowThreads(__tstate);
51212 if (PyErr_Occurred()) SWIG_fail;
51213 }
51214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51215 return resultobj;
51216 fail:
51217 return NULL;
51218 }
51219
51220
51221 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51222 PyObject *resultobj = 0;
51223 wxSizer *arg1 = (wxSizer *) 0 ;
51224 PyObject *arg2 = (PyObject *) 0 ;
51225 bool result;
51226 void *argp1 = 0 ;
51227 int res1 = 0 ;
51228 PyObject * obj0 = 0 ;
51229 PyObject * obj1 = 0 ;
51230 char * kwnames[] = {
51231 (char *) "self",(char *) "item", NULL
51232 };
51233
51234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51236 if (!SWIG_IsOK(res1)) {
51237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51238 }
51239 arg1 = reinterpret_cast< wxSizer * >(argp1);
51240 arg2 = obj1;
51241 {
51242 PyThreadState* __tstate = wxPyBeginAllowThreads();
51243 result = (bool)wxSizer_Remove(arg1,arg2);
51244 wxPyEndAllowThreads(__tstate);
51245 if (PyErr_Occurred()) SWIG_fail;
51246 }
51247 {
51248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51249 }
51250 return resultobj;
51251 fail:
51252 return NULL;
51253 }
51254
51255
51256 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51257 PyObject *resultobj = 0;
51258 wxSizer *arg1 = (wxSizer *) 0 ;
51259 PyObject *arg2 = (PyObject *) 0 ;
51260 bool result;
51261 void *argp1 = 0 ;
51262 int res1 = 0 ;
51263 PyObject * obj0 = 0 ;
51264 PyObject * obj1 = 0 ;
51265 char * kwnames[] = {
51266 (char *) "self",(char *) "item", NULL
51267 };
51268
51269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51271 if (!SWIG_IsOK(res1)) {
51272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51273 }
51274 arg1 = reinterpret_cast< wxSizer * >(argp1);
51275 arg2 = obj1;
51276 {
51277 PyThreadState* __tstate = wxPyBeginAllowThreads();
51278 result = (bool)wxSizer_Detach(arg1,arg2);
51279 wxPyEndAllowThreads(__tstate);
51280 if (PyErr_Occurred()) SWIG_fail;
51281 }
51282 {
51283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51284 }
51285 return resultobj;
51286 fail:
51287 return NULL;
51288 }
51289
51290
51291 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51292 PyObject *resultobj = 0;
51293 wxSizer *arg1 = (wxSizer *) 0 ;
51294 PyObject *arg2 = (PyObject *) 0 ;
51295 bool arg3 = (bool) false ;
51296 wxSizerItem *result = 0 ;
51297 void *argp1 = 0 ;
51298 int res1 = 0 ;
51299 bool val3 ;
51300 int ecode3 = 0 ;
51301 PyObject * obj0 = 0 ;
51302 PyObject * obj1 = 0 ;
51303 PyObject * obj2 = 0 ;
51304 char * kwnames[] = {
51305 (char *) "self",(char *) "item",(char *) "recursive", NULL
51306 };
51307
51308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51310 if (!SWIG_IsOK(res1)) {
51311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51312 }
51313 arg1 = reinterpret_cast< wxSizer * >(argp1);
51314 arg2 = obj1;
51315 if (obj2) {
51316 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51317 if (!SWIG_IsOK(ecode3)) {
51318 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
51319 }
51320 arg3 = static_cast< bool >(val3);
51321 }
51322 {
51323 PyThreadState* __tstate = wxPyBeginAllowThreads();
51324 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
51325 wxPyEndAllowThreads(__tstate);
51326 if (PyErr_Occurred()) SWIG_fail;
51327 }
51328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51329 return resultobj;
51330 fail:
51331 return NULL;
51332 }
51333
51334
51335 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51336 PyObject *resultobj = 0;
51337 wxSizer *arg1 = (wxSizer *) 0 ;
51338 PyObject *arg2 = (PyObject *) 0 ;
51339 wxSize *arg3 = 0 ;
51340 void *argp1 = 0 ;
51341 int res1 = 0 ;
51342 wxSize temp3 ;
51343 PyObject * obj0 = 0 ;
51344 PyObject * obj1 = 0 ;
51345 PyObject * obj2 = 0 ;
51346 char * kwnames[] = {
51347 (char *) "self",(char *) "item",(char *) "size", NULL
51348 };
51349
51350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",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__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51354 }
51355 arg1 = reinterpret_cast< wxSizer * >(argp1);
51356 arg2 = obj1;
51357 {
51358 arg3 = &temp3;
51359 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
51360 }
51361 {
51362 PyThreadState* __tstate = wxPyBeginAllowThreads();
51363 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
51364 wxPyEndAllowThreads(__tstate);
51365 if (PyErr_Occurred()) SWIG_fail;
51366 }
51367 resultobj = SWIG_Py_Void();
51368 return resultobj;
51369 fail:
51370 return NULL;
51371 }
51372
51373
51374 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51375 PyObject *resultobj = 0;
51376 wxSizer *arg1 = (wxSizer *) 0 ;
51377 wxWindow *arg2 = (wxWindow *) 0 ;
51378 wxWindow *arg3 = (wxWindow *) 0 ;
51379 bool arg4 = (bool) false ;
51380 bool result;
51381 void *argp1 = 0 ;
51382 int res1 = 0 ;
51383 void *argp2 = 0 ;
51384 int res2 = 0 ;
51385 void *argp3 = 0 ;
51386 int res3 = 0 ;
51387 bool val4 ;
51388 int ecode4 = 0 ;
51389 PyObject * obj0 = 0 ;
51390 PyObject * obj1 = 0 ;
51391 PyObject * obj2 = 0 ;
51392 PyObject * obj3 = 0 ;
51393 char * kwnames[] = {
51394 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
51395 };
51396
51397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51399 if (!SWIG_IsOK(res1)) {
51400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
51401 }
51402 arg1 = reinterpret_cast< wxSizer * >(argp1);
51403 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51404 if (!SWIG_IsOK(res2)) {
51405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51406 }
51407 arg2 = reinterpret_cast< wxWindow * >(argp2);
51408 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51409 if (!SWIG_IsOK(res3)) {
51410 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
51411 }
51412 arg3 = reinterpret_cast< wxWindow * >(argp3);
51413 if (obj3) {
51414 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51415 if (!SWIG_IsOK(ecode4)) {
51416 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
51417 }
51418 arg4 = static_cast< bool >(val4);
51419 }
51420 {
51421 PyThreadState* __tstate = wxPyBeginAllowThreads();
51422 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51423 wxPyEndAllowThreads(__tstate);
51424 if (PyErr_Occurred()) SWIG_fail;
51425 }
51426 {
51427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51428 }
51429 return resultobj;
51430 fail:
51431 return NULL;
51432 }
51433
51434
51435 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51436 PyObject *resultobj = 0;
51437 wxSizer *arg1 = (wxSizer *) 0 ;
51438 wxSizer *arg2 = (wxSizer *) 0 ;
51439 wxSizer *arg3 = (wxSizer *) 0 ;
51440 bool arg4 = (bool) false ;
51441 bool result;
51442 void *argp1 = 0 ;
51443 int res1 = 0 ;
51444 void *argp2 = 0 ;
51445 int res2 = 0 ;
51446 void *argp3 = 0 ;
51447 int res3 = 0 ;
51448 bool val4 ;
51449 int ecode4 = 0 ;
51450 PyObject * obj0 = 0 ;
51451 PyObject * obj1 = 0 ;
51452 PyObject * obj2 = 0 ;
51453 PyObject * obj3 = 0 ;
51454 char * kwnames[] = {
51455 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
51456 };
51457
51458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51460 if (!SWIG_IsOK(res1)) {
51461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51462 }
51463 arg1 = reinterpret_cast< wxSizer * >(argp1);
51464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51465 if (!SWIG_IsOK(res2)) {
51466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51467 }
51468 arg2 = reinterpret_cast< wxSizer * >(argp2);
51469 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
51470 if (!SWIG_IsOK(res3)) {
51471 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
51472 }
51473 arg3 = reinterpret_cast< wxSizer * >(argp3);
51474 if (obj3) {
51475 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51476 if (!SWIG_IsOK(ecode4)) {
51477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
51478 }
51479 arg4 = static_cast< bool >(val4);
51480 }
51481 {
51482 PyThreadState* __tstate = wxPyBeginAllowThreads();
51483 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51484 wxPyEndAllowThreads(__tstate);
51485 if (PyErr_Occurred()) SWIG_fail;
51486 }
51487 {
51488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51489 }
51490 return resultobj;
51491 fail:
51492 return NULL;
51493 }
51494
51495
51496 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51497 PyObject *resultobj = 0;
51498 wxSizer *arg1 = (wxSizer *) 0 ;
51499 size_t arg2 ;
51500 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51501 bool result;
51502 void *argp1 = 0 ;
51503 int res1 = 0 ;
51504 size_t val2 ;
51505 int ecode2 = 0 ;
51506 void *argp3 = 0 ;
51507 int res3 = 0 ;
51508 PyObject * obj0 = 0 ;
51509 PyObject * obj1 = 0 ;
51510 PyObject * obj2 = 0 ;
51511 char * kwnames[] = {
51512 (char *) "self",(char *) "index",(char *) "newitem", NULL
51513 };
51514
51515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51517 if (!SWIG_IsOK(res1)) {
51518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51519 }
51520 arg1 = reinterpret_cast< wxSizer * >(argp1);
51521 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51522 if (!SWIG_IsOK(ecode2)) {
51523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
51524 }
51525 arg2 = static_cast< size_t >(val2);
51526 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51527 if (!SWIG_IsOK(res3)) {
51528 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51529 }
51530 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
51531 {
51532 PyThreadState* __tstate = wxPyBeginAllowThreads();
51533 result = (bool)(arg1)->Replace(arg2,arg3);
51534 wxPyEndAllowThreads(__tstate);
51535 if (PyErr_Occurred()) SWIG_fail;
51536 }
51537 {
51538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51539 }
51540 return resultobj;
51541 fail:
51542 return NULL;
51543 }
51544
51545
51546 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51547 PyObject *resultobj = 0;
51548 wxSizer *arg1 = (wxSizer *) 0 ;
51549 wxWindow *arg2 = (wxWindow *) 0 ;
51550 void *argp1 = 0 ;
51551 int res1 = 0 ;
51552 void *argp2 = 0 ;
51553 int res2 = 0 ;
51554 PyObject * obj0 = 0 ;
51555 PyObject * obj1 = 0 ;
51556 char * kwnames[] = {
51557 (char *) "self",(char *) "window", NULL
51558 };
51559
51560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51562 if (!SWIG_IsOK(res1)) {
51563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
51564 }
51565 arg1 = reinterpret_cast< wxSizer * >(argp1);
51566 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51567 if (!SWIG_IsOK(res2)) {
51568 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51569 }
51570 arg2 = reinterpret_cast< wxWindow * >(argp2);
51571 {
51572 PyThreadState* __tstate = wxPyBeginAllowThreads();
51573 (arg1)->SetContainingWindow(arg2);
51574 wxPyEndAllowThreads(__tstate);
51575 if (PyErr_Occurred()) SWIG_fail;
51576 }
51577 resultobj = SWIG_Py_Void();
51578 return resultobj;
51579 fail:
51580 return NULL;
51581 }
51582
51583
51584 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51585 PyObject *resultobj = 0;
51586 wxSizer *arg1 = (wxSizer *) 0 ;
51587 wxWindow *result = 0 ;
51588 void *argp1 = 0 ;
51589 int res1 = 0 ;
51590 PyObject *swig_obj[1] ;
51591
51592 if (!args) SWIG_fail;
51593 swig_obj[0] = args;
51594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51595 if (!SWIG_IsOK(res1)) {
51596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
51597 }
51598 arg1 = reinterpret_cast< wxSizer * >(argp1);
51599 {
51600 PyThreadState* __tstate = wxPyBeginAllowThreads();
51601 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
51602 wxPyEndAllowThreads(__tstate);
51603 if (PyErr_Occurred()) SWIG_fail;
51604 }
51605 {
51606 resultobj = wxPyMake_wxObject(result, 0);
51607 }
51608 return resultobj;
51609 fail:
51610 return NULL;
51611 }
51612
51613
51614 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51615 PyObject *resultobj = 0;
51616 wxSizer *arg1 = (wxSizer *) 0 ;
51617 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51618 wxSizerItem *result = 0 ;
51619 void *argp1 = 0 ;
51620 int res1 = 0 ;
51621 int res2 = 0 ;
51622 PyObject * obj0 = 0 ;
51623 PyObject * obj1 = 0 ;
51624 char * kwnames[] = {
51625 (char *) "self",(char *) "item", NULL
51626 };
51627
51628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51630 if (!SWIG_IsOK(res1)) {
51631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51632 }
51633 arg1 = reinterpret_cast< wxSizer * >(argp1);
51634 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51635 if (!SWIG_IsOK(res2)) {
51636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51637 }
51638 {
51639 PyThreadState* __tstate = wxPyBeginAllowThreads();
51640 result = (wxSizerItem *)(arg1)->Add(arg2);
51641 wxPyEndAllowThreads(__tstate);
51642 if (PyErr_Occurred()) SWIG_fail;
51643 }
51644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51645 return resultobj;
51646 fail:
51647 return NULL;
51648 }
51649
51650
51651 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51652 PyObject *resultobj = 0;
51653 wxSizer *arg1 = (wxSizer *) 0 ;
51654 size_t arg2 ;
51655 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51656 wxSizerItem *result = 0 ;
51657 void *argp1 = 0 ;
51658 int res1 = 0 ;
51659 size_t val2 ;
51660 int ecode2 = 0 ;
51661 int res3 = 0 ;
51662 PyObject * obj0 = 0 ;
51663 PyObject * obj1 = 0 ;
51664 PyObject * obj2 = 0 ;
51665 char * kwnames[] = {
51666 (char *) "self",(char *) "index",(char *) "item", NULL
51667 };
51668
51669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51671 if (!SWIG_IsOK(res1)) {
51672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51673 }
51674 arg1 = reinterpret_cast< wxSizer * >(argp1);
51675 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51676 if (!SWIG_IsOK(ecode2)) {
51677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
51678 }
51679 arg2 = static_cast< size_t >(val2);
51680 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51681 if (!SWIG_IsOK(res3)) {
51682 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51683 }
51684 {
51685 PyThreadState* __tstate = wxPyBeginAllowThreads();
51686 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
51687 wxPyEndAllowThreads(__tstate);
51688 if (PyErr_Occurred()) SWIG_fail;
51689 }
51690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51691 return resultobj;
51692 fail:
51693 return NULL;
51694 }
51695
51696
51697 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51698 PyObject *resultobj = 0;
51699 wxSizer *arg1 = (wxSizer *) 0 ;
51700 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51701 wxSizerItem *result = 0 ;
51702 void *argp1 = 0 ;
51703 int res1 = 0 ;
51704 int res2 = 0 ;
51705 PyObject * obj0 = 0 ;
51706 PyObject * obj1 = 0 ;
51707 char * kwnames[] = {
51708 (char *) "self",(char *) "item", NULL
51709 };
51710
51711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) 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_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51715 }
51716 arg1 = reinterpret_cast< wxSizer * >(argp1);
51717 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51718 if (!SWIG_IsOK(res2)) {
51719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51720 }
51721 {
51722 PyThreadState* __tstate = wxPyBeginAllowThreads();
51723 result = (wxSizerItem *)(arg1)->Prepend(arg2);
51724 wxPyEndAllowThreads(__tstate);
51725 if (PyErr_Occurred()) SWIG_fail;
51726 }
51727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51728 return resultobj;
51729 fail:
51730 return NULL;
51731 }
51732
51733
51734 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51735 PyObject *resultobj = 0;
51736 wxSizer *arg1 = (wxSizer *) 0 ;
51737 int arg2 ;
51738 int arg3 ;
51739 int arg4 ;
51740 int arg5 ;
51741 void *argp1 = 0 ;
51742 int res1 = 0 ;
51743 int val2 ;
51744 int ecode2 = 0 ;
51745 int val3 ;
51746 int ecode3 = 0 ;
51747 int val4 ;
51748 int ecode4 = 0 ;
51749 int val5 ;
51750 int ecode5 = 0 ;
51751 PyObject * obj0 = 0 ;
51752 PyObject * obj1 = 0 ;
51753 PyObject * obj2 = 0 ;
51754 PyObject * obj3 = 0 ;
51755 PyObject * obj4 = 0 ;
51756 char * kwnames[] = {
51757 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
51758 };
51759
51760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
51761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51762 if (!SWIG_IsOK(res1)) {
51763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
51764 }
51765 arg1 = reinterpret_cast< wxSizer * >(argp1);
51766 ecode2 = SWIG_AsVal_int(obj1, &val2);
51767 if (!SWIG_IsOK(ecode2)) {
51768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
51769 }
51770 arg2 = static_cast< int >(val2);
51771 ecode3 = SWIG_AsVal_int(obj2, &val3);
51772 if (!SWIG_IsOK(ecode3)) {
51773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
51774 }
51775 arg3 = static_cast< int >(val3);
51776 ecode4 = SWIG_AsVal_int(obj3, &val4);
51777 if (!SWIG_IsOK(ecode4)) {
51778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
51779 }
51780 arg4 = static_cast< int >(val4);
51781 ecode5 = SWIG_AsVal_int(obj4, &val5);
51782 if (!SWIG_IsOK(ecode5)) {
51783 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
51784 }
51785 arg5 = static_cast< int >(val5);
51786 {
51787 PyThreadState* __tstate = wxPyBeginAllowThreads();
51788 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
51789 wxPyEndAllowThreads(__tstate);
51790 if (PyErr_Occurred()) SWIG_fail;
51791 }
51792 resultobj = SWIG_Py_Void();
51793 return resultobj;
51794 fail:
51795 return NULL;
51796 }
51797
51798
51799 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51800 PyObject *resultobj = 0;
51801 wxSizer *arg1 = (wxSizer *) 0 ;
51802 wxSize *arg2 = 0 ;
51803 void *argp1 = 0 ;
51804 int res1 = 0 ;
51805 wxSize temp2 ;
51806 PyObject * obj0 = 0 ;
51807 PyObject * obj1 = 0 ;
51808 char * kwnames[] = {
51809 (char *) "self",(char *) "size", NULL
51810 };
51811
51812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
51813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51814 if (!SWIG_IsOK(res1)) {
51815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51816 }
51817 arg1 = reinterpret_cast< wxSizer * >(argp1);
51818 {
51819 arg2 = &temp2;
51820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51821 }
51822 {
51823 PyThreadState* __tstate = wxPyBeginAllowThreads();
51824 (arg1)->SetMinSize((wxSize const &)*arg2);
51825 wxPyEndAllowThreads(__tstate);
51826 if (PyErr_Occurred()) SWIG_fail;
51827 }
51828 resultobj = SWIG_Py_Void();
51829 return resultobj;
51830 fail:
51831 return NULL;
51832 }
51833
51834
51835 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51836 PyObject *resultobj = 0;
51837 wxSizer *arg1 = (wxSizer *) 0 ;
51838 wxSize result;
51839 void *argp1 = 0 ;
51840 int res1 = 0 ;
51841 PyObject *swig_obj[1] ;
51842
51843 if (!args) SWIG_fail;
51844 swig_obj[0] = args;
51845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51846 if (!SWIG_IsOK(res1)) {
51847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51848 }
51849 arg1 = reinterpret_cast< wxSizer * >(argp1);
51850 {
51851 PyThreadState* __tstate = wxPyBeginAllowThreads();
51852 result = (arg1)->GetSize();
51853 wxPyEndAllowThreads(__tstate);
51854 if (PyErr_Occurred()) SWIG_fail;
51855 }
51856 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51857 return resultobj;
51858 fail:
51859 return NULL;
51860 }
51861
51862
51863 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51864 PyObject *resultobj = 0;
51865 wxSizer *arg1 = (wxSizer *) 0 ;
51866 wxPoint result;
51867 void *argp1 = 0 ;
51868 int res1 = 0 ;
51869 PyObject *swig_obj[1] ;
51870
51871 if (!args) SWIG_fail;
51872 swig_obj[0] = args;
51873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51874 if (!SWIG_IsOK(res1)) {
51875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
51876 }
51877 arg1 = reinterpret_cast< wxSizer * >(argp1);
51878 {
51879 PyThreadState* __tstate = wxPyBeginAllowThreads();
51880 result = (arg1)->GetPosition();
51881 wxPyEndAllowThreads(__tstate);
51882 if (PyErr_Occurred()) SWIG_fail;
51883 }
51884 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51885 return resultobj;
51886 fail:
51887 return NULL;
51888 }
51889
51890
51891 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51892 PyObject *resultobj = 0;
51893 wxSizer *arg1 = (wxSizer *) 0 ;
51894 wxSize result;
51895 void *argp1 = 0 ;
51896 int res1 = 0 ;
51897 PyObject *swig_obj[1] ;
51898
51899 if (!args) SWIG_fail;
51900 swig_obj[0] = args;
51901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51902 if (!SWIG_IsOK(res1)) {
51903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51904 }
51905 arg1 = reinterpret_cast< wxSizer * >(argp1);
51906 {
51907 PyThreadState* __tstate = wxPyBeginAllowThreads();
51908 result = (arg1)->GetMinSize();
51909 wxPyEndAllowThreads(__tstate);
51910 if (PyErr_Occurred()) SWIG_fail;
51911 }
51912 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51913 return resultobj;
51914 fail:
51915 return NULL;
51916 }
51917
51918
51919 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51920 PyObject *resultobj = 0;
51921 wxSizer *arg1 = (wxSizer *) 0 ;
51922 void *argp1 = 0 ;
51923 int res1 = 0 ;
51924 PyObject *swig_obj[1] ;
51925
51926 if (!args) SWIG_fail;
51927 swig_obj[0] = args;
51928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51929 if (!SWIG_IsOK(res1)) {
51930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
51931 }
51932 arg1 = reinterpret_cast< wxSizer * >(argp1);
51933 {
51934 PyThreadState* __tstate = wxPyBeginAllowThreads();
51935 (arg1)->RecalcSizes();
51936 wxPyEndAllowThreads(__tstate);
51937 if (PyErr_Occurred()) SWIG_fail;
51938 }
51939 resultobj = SWIG_Py_Void();
51940 return resultobj;
51941 fail:
51942 return NULL;
51943 }
51944
51945
51946 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51947 PyObject *resultobj = 0;
51948 wxSizer *arg1 = (wxSizer *) 0 ;
51949 wxSize result;
51950 void *argp1 = 0 ;
51951 int res1 = 0 ;
51952 PyObject *swig_obj[1] ;
51953
51954 if (!args) SWIG_fail;
51955 swig_obj[0] = args;
51956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51957 if (!SWIG_IsOK(res1)) {
51958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
51959 }
51960 arg1 = reinterpret_cast< wxSizer * >(argp1);
51961 {
51962 PyThreadState* __tstate = wxPyBeginAllowThreads();
51963 result = (arg1)->CalcMin();
51964 wxPyEndAllowThreads(__tstate);
51965 if (PyErr_Occurred()) SWIG_fail;
51966 }
51967 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51968 return resultobj;
51969 fail:
51970 return NULL;
51971 }
51972
51973
51974 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51975 PyObject *resultobj = 0;
51976 wxSizer *arg1 = (wxSizer *) 0 ;
51977 void *argp1 = 0 ;
51978 int res1 = 0 ;
51979 PyObject *swig_obj[1] ;
51980
51981 if (!args) SWIG_fail;
51982 swig_obj[0] = args;
51983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51984 if (!SWIG_IsOK(res1)) {
51985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
51986 }
51987 arg1 = reinterpret_cast< wxSizer * >(argp1);
51988 {
51989 PyThreadState* __tstate = wxPyBeginAllowThreads();
51990 (arg1)->Layout();
51991 wxPyEndAllowThreads(__tstate);
51992 if (PyErr_Occurred()) SWIG_fail;
51993 }
51994 resultobj = SWIG_Py_Void();
51995 return resultobj;
51996 fail:
51997 return NULL;
51998 }
51999
52000
52001 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52002 PyObject *resultobj = 0;
52003 wxSizer *arg1 = (wxSizer *) 0 ;
52004 wxWindow *arg2 = (wxWindow *) 0 ;
52005 wxSize result;
52006 void *argp1 = 0 ;
52007 int res1 = 0 ;
52008 void *argp2 = 0 ;
52009 int res2 = 0 ;
52010 PyObject * obj0 = 0 ;
52011 PyObject * obj1 = 0 ;
52012 char * kwnames[] = {
52013 (char *) "self",(char *) "window", NULL
52014 };
52015
52016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52018 if (!SWIG_IsOK(res1)) {
52019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52020 }
52021 arg1 = reinterpret_cast< wxSizer * >(argp1);
52022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52023 if (!SWIG_IsOK(res2)) {
52024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52025 }
52026 arg2 = reinterpret_cast< wxWindow * >(argp2);
52027 {
52028 PyThreadState* __tstate = wxPyBeginAllowThreads();
52029 result = (arg1)->Fit(arg2);
52030 wxPyEndAllowThreads(__tstate);
52031 if (PyErr_Occurred()) SWIG_fail;
52032 }
52033 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52034 return resultobj;
52035 fail:
52036 return NULL;
52037 }
52038
52039
52040 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52041 PyObject *resultobj = 0;
52042 wxSizer *arg1 = (wxSizer *) 0 ;
52043 wxWindow *arg2 = (wxWindow *) 0 ;
52044 void *argp1 = 0 ;
52045 int res1 = 0 ;
52046 void *argp2 = 0 ;
52047 int res2 = 0 ;
52048 PyObject * obj0 = 0 ;
52049 PyObject * obj1 = 0 ;
52050 char * kwnames[] = {
52051 (char *) "self",(char *) "window", NULL
52052 };
52053
52054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52056 if (!SWIG_IsOK(res1)) {
52057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52058 }
52059 arg1 = reinterpret_cast< wxSizer * >(argp1);
52060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52061 if (!SWIG_IsOK(res2)) {
52062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52063 }
52064 arg2 = reinterpret_cast< wxWindow * >(argp2);
52065 {
52066 PyThreadState* __tstate = wxPyBeginAllowThreads();
52067 (arg1)->FitInside(arg2);
52068 wxPyEndAllowThreads(__tstate);
52069 if (PyErr_Occurred()) SWIG_fail;
52070 }
52071 resultobj = SWIG_Py_Void();
52072 return resultobj;
52073 fail:
52074 return NULL;
52075 }
52076
52077
52078 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52079 PyObject *resultobj = 0;
52080 wxSizer *arg1 = (wxSizer *) 0 ;
52081 wxWindow *arg2 = (wxWindow *) 0 ;
52082 void *argp1 = 0 ;
52083 int res1 = 0 ;
52084 void *argp2 = 0 ;
52085 int res2 = 0 ;
52086 PyObject * obj0 = 0 ;
52087 PyObject * obj1 = 0 ;
52088 char * kwnames[] = {
52089 (char *) "self",(char *) "window", NULL
52090 };
52091
52092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52094 if (!SWIG_IsOK(res1)) {
52095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52096 }
52097 arg1 = reinterpret_cast< wxSizer * >(argp1);
52098 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52099 if (!SWIG_IsOK(res2)) {
52100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52101 }
52102 arg2 = reinterpret_cast< wxWindow * >(argp2);
52103 {
52104 PyThreadState* __tstate = wxPyBeginAllowThreads();
52105 (arg1)->SetSizeHints(arg2);
52106 wxPyEndAllowThreads(__tstate);
52107 if (PyErr_Occurred()) SWIG_fail;
52108 }
52109 resultobj = SWIG_Py_Void();
52110 return resultobj;
52111 fail:
52112 return NULL;
52113 }
52114
52115
52116 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52117 PyObject *resultobj = 0;
52118 wxSizer *arg1 = (wxSizer *) 0 ;
52119 wxWindow *arg2 = (wxWindow *) 0 ;
52120 void *argp1 = 0 ;
52121 int res1 = 0 ;
52122 void *argp2 = 0 ;
52123 int res2 = 0 ;
52124 PyObject * obj0 = 0 ;
52125 PyObject * obj1 = 0 ;
52126 char * kwnames[] = {
52127 (char *) "self",(char *) "window", NULL
52128 };
52129
52130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52132 if (!SWIG_IsOK(res1)) {
52133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52134 }
52135 arg1 = reinterpret_cast< wxSizer * >(argp1);
52136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52137 if (!SWIG_IsOK(res2)) {
52138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52139 }
52140 arg2 = reinterpret_cast< wxWindow * >(argp2);
52141 {
52142 PyThreadState* __tstate = wxPyBeginAllowThreads();
52143 (arg1)->SetVirtualSizeHints(arg2);
52144 wxPyEndAllowThreads(__tstate);
52145 if (PyErr_Occurred()) SWIG_fail;
52146 }
52147 resultobj = SWIG_Py_Void();
52148 return resultobj;
52149 fail:
52150 return NULL;
52151 }
52152
52153
52154 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52155 PyObject *resultobj = 0;
52156 wxSizer *arg1 = (wxSizer *) 0 ;
52157 bool arg2 = (bool) false ;
52158 void *argp1 = 0 ;
52159 int res1 = 0 ;
52160 bool val2 ;
52161 int ecode2 = 0 ;
52162 PyObject * obj0 = 0 ;
52163 PyObject * obj1 = 0 ;
52164 char * kwnames[] = {
52165 (char *) "self",(char *) "deleteWindows", NULL
52166 };
52167
52168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52170 if (!SWIG_IsOK(res1)) {
52171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52172 }
52173 arg1 = reinterpret_cast< wxSizer * >(argp1);
52174 if (obj1) {
52175 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52176 if (!SWIG_IsOK(ecode2)) {
52177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52178 }
52179 arg2 = static_cast< bool >(val2);
52180 }
52181 {
52182 PyThreadState* __tstate = wxPyBeginAllowThreads();
52183 (arg1)->Clear(arg2);
52184 wxPyEndAllowThreads(__tstate);
52185 if (PyErr_Occurred()) SWIG_fail;
52186 }
52187 resultobj = SWIG_Py_Void();
52188 return resultobj;
52189 fail:
52190 return NULL;
52191 }
52192
52193
52194 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52195 PyObject *resultobj = 0;
52196 wxSizer *arg1 = (wxSizer *) 0 ;
52197 void *argp1 = 0 ;
52198 int res1 = 0 ;
52199 PyObject *swig_obj[1] ;
52200
52201 if (!args) SWIG_fail;
52202 swig_obj[0] = args;
52203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52204 if (!SWIG_IsOK(res1)) {
52205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52206 }
52207 arg1 = reinterpret_cast< wxSizer * >(argp1);
52208 {
52209 PyThreadState* __tstate = wxPyBeginAllowThreads();
52210 (arg1)->DeleteWindows();
52211 wxPyEndAllowThreads(__tstate);
52212 if (PyErr_Occurred()) SWIG_fail;
52213 }
52214 resultobj = SWIG_Py_Void();
52215 return resultobj;
52216 fail:
52217 return NULL;
52218 }
52219
52220
52221 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52222 PyObject *resultobj = 0;
52223 wxSizer *arg1 = (wxSizer *) 0 ;
52224 PyObject *result = 0 ;
52225 void *argp1 = 0 ;
52226 int res1 = 0 ;
52227 PyObject *swig_obj[1] ;
52228
52229 if (!args) SWIG_fail;
52230 swig_obj[0] = args;
52231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52232 if (!SWIG_IsOK(res1)) {
52233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52234 }
52235 arg1 = reinterpret_cast< wxSizer * >(argp1);
52236 {
52237 PyThreadState* __tstate = wxPyBeginAllowThreads();
52238 result = (PyObject *)wxSizer_GetChildren(arg1);
52239 wxPyEndAllowThreads(__tstate);
52240 if (PyErr_Occurred()) SWIG_fail;
52241 }
52242 resultobj = result;
52243 return resultobj;
52244 fail:
52245 return NULL;
52246 }
52247
52248
52249 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52250 PyObject *resultobj = 0;
52251 wxSizer *arg1 = (wxSizer *) 0 ;
52252 PyObject *arg2 = (PyObject *) 0 ;
52253 bool arg3 = (bool) true ;
52254 bool arg4 = (bool) false ;
52255 bool result;
52256 void *argp1 = 0 ;
52257 int res1 = 0 ;
52258 bool val3 ;
52259 int ecode3 = 0 ;
52260 bool val4 ;
52261 int ecode4 = 0 ;
52262 PyObject * obj0 = 0 ;
52263 PyObject * obj1 = 0 ;
52264 PyObject * obj2 = 0 ;
52265 PyObject * obj3 = 0 ;
52266 char * kwnames[] = {
52267 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52268 };
52269
52270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52272 if (!SWIG_IsOK(res1)) {
52273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52274 }
52275 arg1 = reinterpret_cast< wxSizer * >(argp1);
52276 arg2 = obj1;
52277 if (obj2) {
52278 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52279 if (!SWIG_IsOK(ecode3)) {
52280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52281 }
52282 arg3 = static_cast< bool >(val3);
52283 }
52284 if (obj3) {
52285 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52286 if (!SWIG_IsOK(ecode4)) {
52287 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52288 }
52289 arg4 = static_cast< bool >(val4);
52290 }
52291 {
52292 PyThreadState* __tstate = wxPyBeginAllowThreads();
52293 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52294 wxPyEndAllowThreads(__tstate);
52295 if (PyErr_Occurred()) SWIG_fail;
52296 }
52297 {
52298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52299 }
52300 return resultobj;
52301 fail:
52302 return NULL;
52303 }
52304
52305
52306 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52307 PyObject *resultobj = 0;
52308 wxSizer *arg1 = (wxSizer *) 0 ;
52309 PyObject *arg2 = (PyObject *) 0 ;
52310 bool result;
52311 void *argp1 = 0 ;
52312 int res1 = 0 ;
52313 PyObject * obj0 = 0 ;
52314 PyObject * obj1 = 0 ;
52315 char * kwnames[] = {
52316 (char *) "self",(char *) "item", NULL
52317 };
52318
52319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
52320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52321 if (!SWIG_IsOK(res1)) {
52322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
52323 }
52324 arg1 = reinterpret_cast< wxSizer * >(argp1);
52325 arg2 = obj1;
52326 {
52327 PyThreadState* __tstate = wxPyBeginAllowThreads();
52328 result = (bool)wxSizer_IsShown(arg1,arg2);
52329 wxPyEndAllowThreads(__tstate);
52330 if (PyErr_Occurred()) SWIG_fail;
52331 }
52332 {
52333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52334 }
52335 return resultobj;
52336 fail:
52337 return NULL;
52338 }
52339
52340
52341 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52342 PyObject *resultobj = 0;
52343 wxSizer *arg1 = (wxSizer *) 0 ;
52344 bool arg2 ;
52345 void *argp1 = 0 ;
52346 int res1 = 0 ;
52347 bool val2 ;
52348 int ecode2 = 0 ;
52349 PyObject * obj0 = 0 ;
52350 PyObject * obj1 = 0 ;
52351 char * kwnames[] = {
52352 (char *) "self",(char *) "show", NULL
52353 };
52354
52355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
52356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52357 if (!SWIG_IsOK(res1)) {
52358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
52359 }
52360 arg1 = reinterpret_cast< wxSizer * >(argp1);
52361 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52362 if (!SWIG_IsOK(ecode2)) {
52363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
52364 }
52365 arg2 = static_cast< bool >(val2);
52366 {
52367 PyThreadState* __tstate = wxPyBeginAllowThreads();
52368 (arg1)->ShowItems(arg2);
52369 wxPyEndAllowThreads(__tstate);
52370 if (PyErr_Occurred()) SWIG_fail;
52371 }
52372 resultobj = SWIG_Py_Void();
52373 return resultobj;
52374 fail:
52375 return NULL;
52376 }
52377
52378
52379 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52380 PyObject *obj;
52381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52382 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
52383 return SWIG_Py_Void();
52384 }
52385
52386 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52387 PyObject *resultobj = 0;
52388 wxPySizer *result = 0 ;
52389
52390 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
52391 {
52392 PyThreadState* __tstate = wxPyBeginAllowThreads();
52393 result = (wxPySizer *)new wxPySizer();
52394 wxPyEndAllowThreads(__tstate);
52395 if (PyErr_Occurred()) SWIG_fail;
52396 }
52397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
52398 return resultobj;
52399 fail:
52400 return NULL;
52401 }
52402
52403
52404 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52405 PyObject *resultobj = 0;
52406 wxPySizer *arg1 = (wxPySizer *) 0 ;
52407 PyObject *arg2 = (PyObject *) 0 ;
52408 PyObject *arg3 = (PyObject *) 0 ;
52409 void *argp1 = 0 ;
52410 int res1 = 0 ;
52411 PyObject * obj0 = 0 ;
52412 PyObject * obj1 = 0 ;
52413 PyObject * obj2 = 0 ;
52414 char * kwnames[] = {
52415 (char *) "self",(char *) "self",(char *) "_class", NULL
52416 };
52417
52418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
52420 if (!SWIG_IsOK(res1)) {
52421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
52422 }
52423 arg1 = reinterpret_cast< wxPySizer * >(argp1);
52424 arg2 = obj1;
52425 arg3 = obj2;
52426 {
52427 PyThreadState* __tstate = wxPyBeginAllowThreads();
52428 (arg1)->_setCallbackInfo(arg2,arg3);
52429 wxPyEndAllowThreads(__tstate);
52430 if (PyErr_Occurred()) SWIG_fail;
52431 }
52432 resultobj = SWIG_Py_Void();
52433 return resultobj;
52434 fail:
52435 return NULL;
52436 }
52437
52438
52439 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52440 PyObject *obj;
52441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52442 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
52443 return SWIG_Py_Void();
52444 }
52445
52446 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52447 return SWIG_Python_InitShadowInstance(args);
52448 }
52449
52450 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52451 PyObject *resultobj = 0;
52452 int arg1 = (int) wxHORIZONTAL ;
52453 wxBoxSizer *result = 0 ;
52454 int val1 ;
52455 int ecode1 = 0 ;
52456 PyObject * obj0 = 0 ;
52457 char * kwnames[] = {
52458 (char *) "orient", NULL
52459 };
52460
52461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
52462 if (obj0) {
52463 ecode1 = SWIG_AsVal_int(obj0, &val1);
52464 if (!SWIG_IsOK(ecode1)) {
52465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
52466 }
52467 arg1 = static_cast< int >(val1);
52468 }
52469 {
52470 PyThreadState* __tstate = wxPyBeginAllowThreads();
52471 result = (wxBoxSizer *)new wxBoxSizer(arg1);
52472 wxPyEndAllowThreads(__tstate);
52473 if (PyErr_Occurred()) SWIG_fail;
52474 }
52475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
52476 return resultobj;
52477 fail:
52478 return NULL;
52479 }
52480
52481
52482 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52483 PyObject *resultobj = 0;
52484 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52485 int result;
52486 void *argp1 = 0 ;
52487 int res1 = 0 ;
52488 PyObject *swig_obj[1] ;
52489
52490 if (!args) SWIG_fail;
52491 swig_obj[0] = args;
52492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52493 if (!SWIG_IsOK(res1)) {
52494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52495 }
52496 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52497 {
52498 PyThreadState* __tstate = wxPyBeginAllowThreads();
52499 result = (int)(arg1)->GetOrientation();
52500 wxPyEndAllowThreads(__tstate);
52501 if (PyErr_Occurred()) SWIG_fail;
52502 }
52503 resultobj = SWIG_From_int(static_cast< int >(result));
52504 return resultobj;
52505 fail:
52506 return NULL;
52507 }
52508
52509
52510 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52511 PyObject *resultobj = 0;
52512 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52513 int arg2 ;
52514 void *argp1 = 0 ;
52515 int res1 = 0 ;
52516 int val2 ;
52517 int ecode2 = 0 ;
52518 PyObject * obj0 = 0 ;
52519 PyObject * obj1 = 0 ;
52520 char * kwnames[] = {
52521 (char *) "self",(char *) "orient", NULL
52522 };
52523
52524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
52525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52526 if (!SWIG_IsOK(res1)) {
52527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52528 }
52529 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52530 ecode2 = SWIG_AsVal_int(obj1, &val2);
52531 if (!SWIG_IsOK(ecode2)) {
52532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
52533 }
52534 arg2 = static_cast< int >(val2);
52535 {
52536 PyThreadState* __tstate = wxPyBeginAllowThreads();
52537 (arg1)->SetOrientation(arg2);
52538 wxPyEndAllowThreads(__tstate);
52539 if (PyErr_Occurred()) SWIG_fail;
52540 }
52541 resultobj = SWIG_Py_Void();
52542 return resultobj;
52543 fail:
52544 return NULL;
52545 }
52546
52547
52548 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52549 PyObject *obj;
52550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52551 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
52552 return SWIG_Py_Void();
52553 }
52554
52555 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52556 return SWIG_Python_InitShadowInstance(args);
52557 }
52558
52559 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52560 PyObject *resultobj = 0;
52561 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
52562 int arg2 = (int) wxHORIZONTAL ;
52563 wxStaticBoxSizer *result = 0 ;
52564 void *argp1 = 0 ;
52565 int res1 = 0 ;
52566 int val2 ;
52567 int ecode2 = 0 ;
52568 PyObject * obj0 = 0 ;
52569 PyObject * obj1 = 0 ;
52570 char * kwnames[] = {
52571 (char *) "box",(char *) "orient", NULL
52572 };
52573
52574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
52575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
52576 if (!SWIG_IsOK(res1)) {
52577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
52578 }
52579 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
52580 if (obj1) {
52581 ecode2 = SWIG_AsVal_int(obj1, &val2);
52582 if (!SWIG_IsOK(ecode2)) {
52583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
52584 }
52585 arg2 = static_cast< int >(val2);
52586 }
52587 {
52588 PyThreadState* __tstate = wxPyBeginAllowThreads();
52589 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
52590 wxPyEndAllowThreads(__tstate);
52591 if (PyErr_Occurred()) SWIG_fail;
52592 }
52593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
52594 return resultobj;
52595 fail:
52596 return NULL;
52597 }
52598
52599
52600 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52601 PyObject *resultobj = 0;
52602 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
52603 wxStaticBox *result = 0 ;
52604 void *argp1 = 0 ;
52605 int res1 = 0 ;
52606 PyObject *swig_obj[1] ;
52607
52608 if (!args) SWIG_fail;
52609 swig_obj[0] = args;
52610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
52611 if (!SWIG_IsOK(res1)) {
52612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
52613 }
52614 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
52615 {
52616 PyThreadState* __tstate = wxPyBeginAllowThreads();
52617 result = (wxStaticBox *)(arg1)->GetStaticBox();
52618 wxPyEndAllowThreads(__tstate);
52619 if (PyErr_Occurred()) SWIG_fail;
52620 }
52621 {
52622 resultobj = wxPyMake_wxObject(result, (bool)0);
52623 }
52624 return resultobj;
52625 fail:
52626 return NULL;
52627 }
52628
52629
52630 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52631 PyObject *obj;
52632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52633 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
52634 return SWIG_Py_Void();
52635 }
52636
52637 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52638 return SWIG_Python_InitShadowInstance(args);
52639 }
52640
52641 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52642 PyObject *resultobj = 0;
52643 int arg1 = (int) 1 ;
52644 int arg2 = (int) 0 ;
52645 int arg3 = (int) 0 ;
52646 int arg4 = (int) 0 ;
52647 wxGridSizer *result = 0 ;
52648 int val1 ;
52649 int ecode1 = 0 ;
52650 int val2 ;
52651 int ecode2 = 0 ;
52652 int val3 ;
52653 int ecode3 = 0 ;
52654 int val4 ;
52655 int ecode4 = 0 ;
52656 PyObject * obj0 = 0 ;
52657 PyObject * obj1 = 0 ;
52658 PyObject * obj2 = 0 ;
52659 PyObject * obj3 = 0 ;
52660 char * kwnames[] = {
52661 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
52662 };
52663
52664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52665 if (obj0) {
52666 ecode1 = SWIG_AsVal_int(obj0, &val1);
52667 if (!SWIG_IsOK(ecode1)) {
52668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
52669 }
52670 arg1 = static_cast< int >(val1);
52671 }
52672 if (obj1) {
52673 ecode2 = SWIG_AsVal_int(obj1, &val2);
52674 if (!SWIG_IsOK(ecode2)) {
52675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
52676 }
52677 arg2 = static_cast< int >(val2);
52678 }
52679 if (obj2) {
52680 ecode3 = SWIG_AsVal_int(obj2, &val3);
52681 if (!SWIG_IsOK(ecode3)) {
52682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
52683 }
52684 arg3 = static_cast< int >(val3);
52685 }
52686 if (obj3) {
52687 ecode4 = SWIG_AsVal_int(obj3, &val4);
52688 if (!SWIG_IsOK(ecode4)) {
52689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
52690 }
52691 arg4 = static_cast< int >(val4);
52692 }
52693 {
52694 PyThreadState* __tstate = wxPyBeginAllowThreads();
52695 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
52696 wxPyEndAllowThreads(__tstate);
52697 if (PyErr_Occurred()) SWIG_fail;
52698 }
52699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
52700 return resultobj;
52701 fail:
52702 return NULL;
52703 }
52704
52705
52706 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52707 PyObject *resultobj = 0;
52708 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52709 int arg2 ;
52710 void *argp1 = 0 ;
52711 int res1 = 0 ;
52712 int val2 ;
52713 int ecode2 = 0 ;
52714 PyObject * obj0 = 0 ;
52715 PyObject * obj1 = 0 ;
52716 char * kwnames[] = {
52717 (char *) "self",(char *) "cols", NULL
52718 };
52719
52720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
52721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52722 if (!SWIG_IsOK(res1)) {
52723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52724 }
52725 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52726 ecode2 = SWIG_AsVal_int(obj1, &val2);
52727 if (!SWIG_IsOK(ecode2)) {
52728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
52729 }
52730 arg2 = static_cast< int >(val2);
52731 {
52732 PyThreadState* __tstate = wxPyBeginAllowThreads();
52733 (arg1)->SetCols(arg2);
52734 wxPyEndAllowThreads(__tstate);
52735 if (PyErr_Occurred()) SWIG_fail;
52736 }
52737 resultobj = SWIG_Py_Void();
52738 return resultobj;
52739 fail:
52740 return NULL;
52741 }
52742
52743
52744 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52745 PyObject *resultobj = 0;
52746 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52747 int arg2 ;
52748 void *argp1 = 0 ;
52749 int res1 = 0 ;
52750 int val2 ;
52751 int ecode2 = 0 ;
52752 PyObject * obj0 = 0 ;
52753 PyObject * obj1 = 0 ;
52754 char * kwnames[] = {
52755 (char *) "self",(char *) "rows", NULL
52756 };
52757
52758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
52759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52760 if (!SWIG_IsOK(res1)) {
52761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52762 }
52763 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52764 ecode2 = SWIG_AsVal_int(obj1, &val2);
52765 if (!SWIG_IsOK(ecode2)) {
52766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
52767 }
52768 arg2 = static_cast< int >(val2);
52769 {
52770 PyThreadState* __tstate = wxPyBeginAllowThreads();
52771 (arg1)->SetRows(arg2);
52772 wxPyEndAllowThreads(__tstate);
52773 if (PyErr_Occurred()) SWIG_fail;
52774 }
52775 resultobj = SWIG_Py_Void();
52776 return resultobj;
52777 fail:
52778 return NULL;
52779 }
52780
52781
52782 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52783 PyObject *resultobj = 0;
52784 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52785 int arg2 ;
52786 void *argp1 = 0 ;
52787 int res1 = 0 ;
52788 int val2 ;
52789 int ecode2 = 0 ;
52790 PyObject * obj0 = 0 ;
52791 PyObject * obj1 = 0 ;
52792 char * kwnames[] = {
52793 (char *) "self",(char *) "gap", NULL
52794 };
52795
52796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
52797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52798 if (!SWIG_IsOK(res1)) {
52799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52800 }
52801 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52802 ecode2 = SWIG_AsVal_int(obj1, &val2);
52803 if (!SWIG_IsOK(ecode2)) {
52804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
52805 }
52806 arg2 = static_cast< int >(val2);
52807 {
52808 PyThreadState* __tstate = wxPyBeginAllowThreads();
52809 (arg1)->SetVGap(arg2);
52810 wxPyEndAllowThreads(__tstate);
52811 if (PyErr_Occurred()) SWIG_fail;
52812 }
52813 resultobj = SWIG_Py_Void();
52814 return resultobj;
52815 fail:
52816 return NULL;
52817 }
52818
52819
52820 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52821 PyObject *resultobj = 0;
52822 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52823 int arg2 ;
52824 void *argp1 = 0 ;
52825 int res1 = 0 ;
52826 int val2 ;
52827 int ecode2 = 0 ;
52828 PyObject * obj0 = 0 ;
52829 PyObject * obj1 = 0 ;
52830 char * kwnames[] = {
52831 (char *) "self",(char *) "gap", NULL
52832 };
52833
52834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
52835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52836 if (!SWIG_IsOK(res1)) {
52837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52838 }
52839 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52840 ecode2 = SWIG_AsVal_int(obj1, &val2);
52841 if (!SWIG_IsOK(ecode2)) {
52842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
52843 }
52844 arg2 = static_cast< int >(val2);
52845 {
52846 PyThreadState* __tstate = wxPyBeginAllowThreads();
52847 (arg1)->SetHGap(arg2);
52848 wxPyEndAllowThreads(__tstate);
52849 if (PyErr_Occurred()) SWIG_fail;
52850 }
52851 resultobj = SWIG_Py_Void();
52852 return resultobj;
52853 fail:
52854 return NULL;
52855 }
52856
52857
52858 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52859 PyObject *resultobj = 0;
52860 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52861 int result;
52862 void *argp1 = 0 ;
52863 int res1 = 0 ;
52864 PyObject *swig_obj[1] ;
52865
52866 if (!args) SWIG_fail;
52867 swig_obj[0] = args;
52868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52869 if (!SWIG_IsOK(res1)) {
52870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52871 }
52872 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52873 {
52874 PyThreadState* __tstate = wxPyBeginAllowThreads();
52875 result = (int)(arg1)->GetCols();
52876 wxPyEndAllowThreads(__tstate);
52877 if (PyErr_Occurred()) SWIG_fail;
52878 }
52879 resultobj = SWIG_From_int(static_cast< int >(result));
52880 return resultobj;
52881 fail:
52882 return NULL;
52883 }
52884
52885
52886 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52887 PyObject *resultobj = 0;
52888 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52889 int result;
52890 void *argp1 = 0 ;
52891 int res1 = 0 ;
52892 PyObject *swig_obj[1] ;
52893
52894 if (!args) SWIG_fail;
52895 swig_obj[0] = args;
52896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52897 if (!SWIG_IsOK(res1)) {
52898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52899 }
52900 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52901 {
52902 PyThreadState* __tstate = wxPyBeginAllowThreads();
52903 result = (int)(arg1)->GetRows();
52904 wxPyEndAllowThreads(__tstate);
52905 if (PyErr_Occurred()) SWIG_fail;
52906 }
52907 resultobj = SWIG_From_int(static_cast< int >(result));
52908 return resultobj;
52909 fail:
52910 return NULL;
52911 }
52912
52913
52914 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52915 PyObject *resultobj = 0;
52916 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52917 int result;
52918 void *argp1 = 0 ;
52919 int res1 = 0 ;
52920 PyObject *swig_obj[1] ;
52921
52922 if (!args) SWIG_fail;
52923 swig_obj[0] = args;
52924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52925 if (!SWIG_IsOK(res1)) {
52926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52927 }
52928 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52929 {
52930 PyThreadState* __tstate = wxPyBeginAllowThreads();
52931 result = (int)(arg1)->GetVGap();
52932 wxPyEndAllowThreads(__tstate);
52933 if (PyErr_Occurred()) SWIG_fail;
52934 }
52935 resultobj = SWIG_From_int(static_cast< int >(result));
52936 return resultobj;
52937 fail:
52938 return NULL;
52939 }
52940
52941
52942 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52943 PyObject *resultobj = 0;
52944 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52945 int result;
52946 void *argp1 = 0 ;
52947 int res1 = 0 ;
52948 PyObject *swig_obj[1] ;
52949
52950 if (!args) SWIG_fail;
52951 swig_obj[0] = args;
52952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52953 if (!SWIG_IsOK(res1)) {
52954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52955 }
52956 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52957 {
52958 PyThreadState* __tstate = wxPyBeginAllowThreads();
52959 result = (int)(arg1)->GetHGap();
52960 wxPyEndAllowThreads(__tstate);
52961 if (PyErr_Occurred()) SWIG_fail;
52962 }
52963 resultobj = SWIG_From_int(static_cast< int >(result));
52964 return resultobj;
52965 fail:
52966 return NULL;
52967 }
52968
52969
52970 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52971 PyObject *obj;
52972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52973 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
52974 return SWIG_Py_Void();
52975 }
52976
52977 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52978 return SWIG_Python_InitShadowInstance(args);
52979 }
52980
52981 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52982 PyObject *resultobj = 0;
52983 int arg1 = (int) 1 ;
52984 int arg2 = (int) 0 ;
52985 int arg3 = (int) 0 ;
52986 int arg4 = (int) 0 ;
52987 wxFlexGridSizer *result = 0 ;
52988 int val1 ;
52989 int ecode1 = 0 ;
52990 int val2 ;
52991 int ecode2 = 0 ;
52992 int val3 ;
52993 int ecode3 = 0 ;
52994 int val4 ;
52995 int ecode4 = 0 ;
52996 PyObject * obj0 = 0 ;
52997 PyObject * obj1 = 0 ;
52998 PyObject * obj2 = 0 ;
52999 PyObject * obj3 = 0 ;
53000 char * kwnames[] = {
53001 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53002 };
53003
53004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53005 if (obj0) {
53006 ecode1 = SWIG_AsVal_int(obj0, &val1);
53007 if (!SWIG_IsOK(ecode1)) {
53008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53009 }
53010 arg1 = static_cast< int >(val1);
53011 }
53012 if (obj1) {
53013 ecode2 = SWIG_AsVal_int(obj1, &val2);
53014 if (!SWIG_IsOK(ecode2)) {
53015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53016 }
53017 arg2 = static_cast< int >(val2);
53018 }
53019 if (obj2) {
53020 ecode3 = SWIG_AsVal_int(obj2, &val3);
53021 if (!SWIG_IsOK(ecode3)) {
53022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53023 }
53024 arg3 = static_cast< int >(val3);
53025 }
53026 if (obj3) {
53027 ecode4 = SWIG_AsVal_int(obj3, &val4);
53028 if (!SWIG_IsOK(ecode4)) {
53029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53030 }
53031 arg4 = static_cast< int >(val4);
53032 }
53033 {
53034 PyThreadState* __tstate = wxPyBeginAllowThreads();
53035 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53036 wxPyEndAllowThreads(__tstate);
53037 if (PyErr_Occurred()) SWIG_fail;
53038 }
53039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53040 return resultobj;
53041 fail:
53042 return NULL;
53043 }
53044
53045
53046 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53047 PyObject *resultobj = 0;
53048 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53049 size_t arg2 ;
53050 int arg3 = (int) 0 ;
53051 void *argp1 = 0 ;
53052 int res1 = 0 ;
53053 size_t val2 ;
53054 int ecode2 = 0 ;
53055 int val3 ;
53056 int ecode3 = 0 ;
53057 PyObject * obj0 = 0 ;
53058 PyObject * obj1 = 0 ;
53059 PyObject * obj2 = 0 ;
53060 char * kwnames[] = {
53061 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53062 };
53063
53064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53066 if (!SWIG_IsOK(res1)) {
53067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53068 }
53069 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53070 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53071 if (!SWIG_IsOK(ecode2)) {
53072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53073 }
53074 arg2 = static_cast< size_t >(val2);
53075 if (obj2) {
53076 ecode3 = SWIG_AsVal_int(obj2, &val3);
53077 if (!SWIG_IsOK(ecode3)) {
53078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53079 }
53080 arg3 = static_cast< int >(val3);
53081 }
53082 {
53083 PyThreadState* __tstate = wxPyBeginAllowThreads();
53084 (arg1)->AddGrowableRow(arg2,arg3);
53085 wxPyEndAllowThreads(__tstate);
53086 if (PyErr_Occurred()) SWIG_fail;
53087 }
53088 resultobj = SWIG_Py_Void();
53089 return resultobj;
53090 fail:
53091 return NULL;
53092 }
53093
53094
53095 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53096 PyObject *resultobj = 0;
53097 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53098 size_t arg2 ;
53099 void *argp1 = 0 ;
53100 int res1 = 0 ;
53101 size_t val2 ;
53102 int ecode2 = 0 ;
53103 PyObject * obj0 = 0 ;
53104 PyObject * obj1 = 0 ;
53105 char * kwnames[] = {
53106 (char *) "self",(char *) "idx", NULL
53107 };
53108
53109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53111 if (!SWIG_IsOK(res1)) {
53112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53113 }
53114 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53115 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53116 if (!SWIG_IsOK(ecode2)) {
53117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53118 }
53119 arg2 = static_cast< size_t >(val2);
53120 {
53121 PyThreadState* __tstate = wxPyBeginAllowThreads();
53122 (arg1)->RemoveGrowableRow(arg2);
53123 wxPyEndAllowThreads(__tstate);
53124 if (PyErr_Occurred()) SWIG_fail;
53125 }
53126 resultobj = SWIG_Py_Void();
53127 return resultobj;
53128 fail:
53129 return NULL;
53130 }
53131
53132
53133 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53134 PyObject *resultobj = 0;
53135 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53136 size_t arg2 ;
53137 int arg3 = (int) 0 ;
53138 void *argp1 = 0 ;
53139 int res1 = 0 ;
53140 size_t val2 ;
53141 int ecode2 = 0 ;
53142 int val3 ;
53143 int ecode3 = 0 ;
53144 PyObject * obj0 = 0 ;
53145 PyObject * obj1 = 0 ;
53146 PyObject * obj2 = 0 ;
53147 char * kwnames[] = {
53148 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53149 };
53150
53151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) 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_AddGrowableCol" "', 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_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53160 }
53161 arg2 = static_cast< size_t >(val2);
53162 if (obj2) {
53163 ecode3 = SWIG_AsVal_int(obj2, &val3);
53164 if (!SWIG_IsOK(ecode3)) {
53165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53166 }
53167 arg3 = static_cast< int >(val3);
53168 }
53169 {
53170 PyThreadState* __tstate = wxPyBeginAllowThreads();
53171 (arg1)->AddGrowableCol(arg2,arg3);
53172 wxPyEndAllowThreads(__tstate);
53173 if (PyErr_Occurred()) SWIG_fail;
53174 }
53175 resultobj = SWIG_Py_Void();
53176 return resultobj;
53177 fail:
53178 return NULL;
53179 }
53180
53181
53182 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53183 PyObject *resultobj = 0;
53184 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53185 size_t arg2 ;
53186 void *argp1 = 0 ;
53187 int res1 = 0 ;
53188 size_t val2 ;
53189 int ecode2 = 0 ;
53190 PyObject * obj0 = 0 ;
53191 PyObject * obj1 = 0 ;
53192 char * kwnames[] = {
53193 (char *) "self",(char *) "idx", NULL
53194 };
53195
53196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53198 if (!SWIG_IsOK(res1)) {
53199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53200 }
53201 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53202 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53203 if (!SWIG_IsOK(ecode2)) {
53204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53205 }
53206 arg2 = static_cast< size_t >(val2);
53207 {
53208 PyThreadState* __tstate = wxPyBeginAllowThreads();
53209 (arg1)->RemoveGrowableCol(arg2);
53210 wxPyEndAllowThreads(__tstate);
53211 if (PyErr_Occurred()) SWIG_fail;
53212 }
53213 resultobj = SWIG_Py_Void();
53214 return resultobj;
53215 fail:
53216 return NULL;
53217 }
53218
53219
53220 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53221 PyObject *resultobj = 0;
53222 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53223 int arg2 ;
53224 void *argp1 = 0 ;
53225 int res1 = 0 ;
53226 int val2 ;
53227 int ecode2 = 0 ;
53228 PyObject * obj0 = 0 ;
53229 PyObject * obj1 = 0 ;
53230 char * kwnames[] = {
53231 (char *) "self",(char *) "direction", NULL
53232 };
53233
53234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53236 if (!SWIG_IsOK(res1)) {
53237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53238 }
53239 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53240 ecode2 = SWIG_AsVal_int(obj1, &val2);
53241 if (!SWIG_IsOK(ecode2)) {
53242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53243 }
53244 arg2 = static_cast< int >(val2);
53245 {
53246 PyThreadState* __tstate = wxPyBeginAllowThreads();
53247 (arg1)->SetFlexibleDirection(arg2);
53248 wxPyEndAllowThreads(__tstate);
53249 if (PyErr_Occurred()) SWIG_fail;
53250 }
53251 resultobj = SWIG_Py_Void();
53252 return resultobj;
53253 fail:
53254 return NULL;
53255 }
53256
53257
53258 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53259 PyObject *resultobj = 0;
53260 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53261 int result;
53262 void *argp1 = 0 ;
53263 int res1 = 0 ;
53264 PyObject *swig_obj[1] ;
53265
53266 if (!args) SWIG_fail;
53267 swig_obj[0] = args;
53268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53269 if (!SWIG_IsOK(res1)) {
53270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53271 }
53272 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53273 {
53274 PyThreadState* __tstate = wxPyBeginAllowThreads();
53275 result = (int)(arg1)->GetFlexibleDirection();
53276 wxPyEndAllowThreads(__tstate);
53277 if (PyErr_Occurred()) SWIG_fail;
53278 }
53279 resultobj = SWIG_From_int(static_cast< int >(result));
53280 return resultobj;
53281 fail:
53282 return NULL;
53283 }
53284
53285
53286 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53287 PyObject *resultobj = 0;
53288 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53289 wxFlexSizerGrowMode arg2 ;
53290 void *argp1 = 0 ;
53291 int res1 = 0 ;
53292 int val2 ;
53293 int ecode2 = 0 ;
53294 PyObject * obj0 = 0 ;
53295 PyObject * obj1 = 0 ;
53296 char * kwnames[] = {
53297 (char *) "self",(char *) "mode", NULL
53298 };
53299
53300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53302 if (!SWIG_IsOK(res1)) {
53303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53304 }
53305 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53306 ecode2 = SWIG_AsVal_int(obj1, &val2);
53307 if (!SWIG_IsOK(ecode2)) {
53308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
53309 }
53310 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
53311 {
53312 PyThreadState* __tstate = wxPyBeginAllowThreads();
53313 (arg1)->SetNonFlexibleGrowMode(arg2);
53314 wxPyEndAllowThreads(__tstate);
53315 if (PyErr_Occurred()) SWIG_fail;
53316 }
53317 resultobj = SWIG_Py_Void();
53318 return resultobj;
53319 fail:
53320 return NULL;
53321 }
53322
53323
53324 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53325 PyObject *resultobj = 0;
53326 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53327 wxFlexSizerGrowMode result;
53328 void *argp1 = 0 ;
53329 int res1 = 0 ;
53330 PyObject *swig_obj[1] ;
53331
53332 if (!args) SWIG_fail;
53333 swig_obj[0] = args;
53334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53335 if (!SWIG_IsOK(res1)) {
53336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53337 }
53338 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53339 {
53340 PyThreadState* __tstate = wxPyBeginAllowThreads();
53341 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
53342 wxPyEndAllowThreads(__tstate);
53343 if (PyErr_Occurred()) SWIG_fail;
53344 }
53345 resultobj = SWIG_From_int(static_cast< int >(result));
53346 return resultobj;
53347 fail:
53348 return NULL;
53349 }
53350
53351
53352 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53353 PyObject *resultobj = 0;
53354 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53355 wxArrayInt *result = 0 ;
53356 void *argp1 = 0 ;
53357 int res1 = 0 ;
53358 PyObject *swig_obj[1] ;
53359
53360 if (!args) SWIG_fail;
53361 swig_obj[0] = args;
53362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53363 if (!SWIG_IsOK(res1)) {
53364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53365 }
53366 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53367 {
53368 PyThreadState* __tstate = wxPyBeginAllowThreads();
53369 {
53370 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
53371 result = (wxArrayInt *) &_result_ref;
53372 }
53373 wxPyEndAllowThreads(__tstate);
53374 if (PyErr_Occurred()) SWIG_fail;
53375 }
53376 {
53377 resultobj = wxArrayInt2PyList_helper(*result);
53378 }
53379 return resultobj;
53380 fail:
53381 return NULL;
53382 }
53383
53384
53385 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53386 PyObject *resultobj = 0;
53387 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53388 wxArrayInt *result = 0 ;
53389 void *argp1 = 0 ;
53390 int res1 = 0 ;
53391 PyObject *swig_obj[1] ;
53392
53393 if (!args) SWIG_fail;
53394 swig_obj[0] = args;
53395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53396 if (!SWIG_IsOK(res1)) {
53397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53398 }
53399 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53400 {
53401 PyThreadState* __tstate = wxPyBeginAllowThreads();
53402 {
53403 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
53404 result = (wxArrayInt *) &_result_ref;
53405 }
53406 wxPyEndAllowThreads(__tstate);
53407 if (PyErr_Occurred()) SWIG_fail;
53408 }
53409 {
53410 resultobj = wxArrayInt2PyList_helper(*result);
53411 }
53412 return resultobj;
53413 fail:
53414 return NULL;
53415 }
53416
53417
53418 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53419 PyObject *obj;
53420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53421 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
53422 return SWIG_Py_Void();
53423 }
53424
53425 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53426 return SWIG_Python_InitShadowInstance(args);
53427 }
53428
53429 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53430 PyObject *resultobj = 0;
53431 wxStdDialogButtonSizer *result = 0 ;
53432
53433 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
53434 {
53435 PyThreadState* __tstate = wxPyBeginAllowThreads();
53436 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
53437 wxPyEndAllowThreads(__tstate);
53438 if (PyErr_Occurred()) SWIG_fail;
53439 }
53440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
53441 return resultobj;
53442 fail:
53443 return NULL;
53444 }
53445
53446
53447 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53448 PyObject *resultobj = 0;
53449 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53450 wxButton *arg2 = (wxButton *) 0 ;
53451 void *argp1 = 0 ;
53452 int res1 = 0 ;
53453 void *argp2 = 0 ;
53454 int res2 = 0 ;
53455 PyObject * obj0 = 0 ;
53456 PyObject * obj1 = 0 ;
53457 char * kwnames[] = {
53458 (char *) "self",(char *) "button", NULL
53459 };
53460
53461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
53462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53463 if (!SWIG_IsOK(res1)) {
53464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53465 }
53466 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53468 if (!SWIG_IsOK(res2)) {
53469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
53470 }
53471 arg2 = reinterpret_cast< wxButton * >(argp2);
53472 {
53473 PyThreadState* __tstate = wxPyBeginAllowThreads();
53474 (arg1)->AddButton(arg2);
53475 wxPyEndAllowThreads(__tstate);
53476 if (PyErr_Occurred()) SWIG_fail;
53477 }
53478 resultobj = SWIG_Py_Void();
53479 return resultobj;
53480 fail:
53481 return NULL;
53482 }
53483
53484
53485 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53486 PyObject *resultobj = 0;
53487 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53488 void *argp1 = 0 ;
53489 int res1 = 0 ;
53490 PyObject *swig_obj[1] ;
53491
53492 if (!args) SWIG_fail;
53493 swig_obj[0] = args;
53494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53495 if (!SWIG_IsOK(res1)) {
53496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53497 }
53498 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53499 {
53500 PyThreadState* __tstate = wxPyBeginAllowThreads();
53501 (arg1)->Realize();
53502 wxPyEndAllowThreads(__tstate);
53503 if (PyErr_Occurred()) SWIG_fail;
53504 }
53505 resultobj = SWIG_Py_Void();
53506 return resultobj;
53507 fail:
53508 return NULL;
53509 }
53510
53511
53512 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53513 PyObject *resultobj = 0;
53514 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53515 wxButton *arg2 = (wxButton *) 0 ;
53516 void *argp1 = 0 ;
53517 int res1 = 0 ;
53518 void *argp2 = 0 ;
53519 int res2 = 0 ;
53520 PyObject * obj0 = 0 ;
53521 PyObject * obj1 = 0 ;
53522 char * kwnames[] = {
53523 (char *) "self",(char *) "button", NULL
53524 };
53525
53526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53528 if (!SWIG_IsOK(res1)) {
53529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53530 }
53531 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53533 if (!SWIG_IsOK(res2)) {
53534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53535 }
53536 arg2 = reinterpret_cast< wxButton * >(argp2);
53537 {
53538 PyThreadState* __tstate = wxPyBeginAllowThreads();
53539 (arg1)->SetAffirmativeButton(arg2);
53540 wxPyEndAllowThreads(__tstate);
53541 if (PyErr_Occurred()) SWIG_fail;
53542 }
53543 resultobj = SWIG_Py_Void();
53544 return resultobj;
53545 fail:
53546 return NULL;
53547 }
53548
53549
53550 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53551 PyObject *resultobj = 0;
53552 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53553 wxButton *arg2 = (wxButton *) 0 ;
53554 void *argp1 = 0 ;
53555 int res1 = 0 ;
53556 void *argp2 = 0 ;
53557 int res2 = 0 ;
53558 PyObject * obj0 = 0 ;
53559 PyObject * obj1 = 0 ;
53560 char * kwnames[] = {
53561 (char *) "self",(char *) "button", NULL
53562 };
53563
53564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53566 if (!SWIG_IsOK(res1)) {
53567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53568 }
53569 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53571 if (!SWIG_IsOK(res2)) {
53572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53573 }
53574 arg2 = reinterpret_cast< wxButton * >(argp2);
53575 {
53576 PyThreadState* __tstate = wxPyBeginAllowThreads();
53577 (arg1)->SetNegativeButton(arg2);
53578 wxPyEndAllowThreads(__tstate);
53579 if (PyErr_Occurred()) SWIG_fail;
53580 }
53581 resultobj = SWIG_Py_Void();
53582 return resultobj;
53583 fail:
53584 return NULL;
53585 }
53586
53587
53588 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53589 PyObject *resultobj = 0;
53590 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53591 wxButton *arg2 = (wxButton *) 0 ;
53592 void *argp1 = 0 ;
53593 int res1 = 0 ;
53594 void *argp2 = 0 ;
53595 int res2 = 0 ;
53596 PyObject * obj0 = 0 ;
53597 PyObject * obj1 = 0 ;
53598 char * kwnames[] = {
53599 (char *) "self",(char *) "button", NULL
53600 };
53601
53602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
53603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53604 if (!SWIG_IsOK(res1)) {
53605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53606 }
53607 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53609 if (!SWIG_IsOK(res2)) {
53610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
53611 }
53612 arg2 = reinterpret_cast< wxButton * >(argp2);
53613 {
53614 PyThreadState* __tstate = wxPyBeginAllowThreads();
53615 (arg1)->SetCancelButton(arg2);
53616 wxPyEndAllowThreads(__tstate);
53617 if (PyErr_Occurred()) SWIG_fail;
53618 }
53619 resultobj = SWIG_Py_Void();
53620 return resultobj;
53621 fail:
53622 return NULL;
53623 }
53624
53625
53626 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53627 PyObject *resultobj = 0;
53628 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53629 wxButton *result = 0 ;
53630 void *argp1 = 0 ;
53631 int res1 = 0 ;
53632 PyObject *swig_obj[1] ;
53633
53634 if (!args) SWIG_fail;
53635 swig_obj[0] = args;
53636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53637 if (!SWIG_IsOK(res1)) {
53638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53639 }
53640 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53641 {
53642 PyThreadState* __tstate = wxPyBeginAllowThreads();
53643 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
53644 wxPyEndAllowThreads(__tstate);
53645 if (PyErr_Occurred()) SWIG_fail;
53646 }
53647 {
53648 resultobj = wxPyMake_wxObject(result, (bool)0);
53649 }
53650 return resultobj;
53651 fail:
53652 return NULL;
53653 }
53654
53655
53656 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53657 PyObject *resultobj = 0;
53658 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53659 wxButton *result = 0 ;
53660 void *argp1 = 0 ;
53661 int res1 = 0 ;
53662 PyObject *swig_obj[1] ;
53663
53664 if (!args) SWIG_fail;
53665 swig_obj[0] = args;
53666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53667 if (!SWIG_IsOK(res1)) {
53668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53669 }
53670 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53671 {
53672 PyThreadState* __tstate = wxPyBeginAllowThreads();
53673 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
53674 wxPyEndAllowThreads(__tstate);
53675 if (PyErr_Occurred()) SWIG_fail;
53676 }
53677 {
53678 resultobj = wxPyMake_wxObject(result, (bool)0);
53679 }
53680 return resultobj;
53681 fail:
53682 return NULL;
53683 }
53684
53685
53686 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53687 PyObject *resultobj = 0;
53688 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53689 wxButton *result = 0 ;
53690 void *argp1 = 0 ;
53691 int res1 = 0 ;
53692 PyObject *swig_obj[1] ;
53693
53694 if (!args) SWIG_fail;
53695 swig_obj[0] = args;
53696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53697 if (!SWIG_IsOK(res1)) {
53698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53699 }
53700 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53701 {
53702 PyThreadState* __tstate = wxPyBeginAllowThreads();
53703 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
53704 wxPyEndAllowThreads(__tstate);
53705 if (PyErr_Occurred()) SWIG_fail;
53706 }
53707 {
53708 resultobj = wxPyMake_wxObject(result, (bool)0);
53709 }
53710 return resultobj;
53711 fail:
53712 return NULL;
53713 }
53714
53715
53716 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53717 PyObject *resultobj = 0;
53718 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53719 wxButton *result = 0 ;
53720 void *argp1 = 0 ;
53721 int res1 = 0 ;
53722 PyObject *swig_obj[1] ;
53723
53724 if (!args) SWIG_fail;
53725 swig_obj[0] = args;
53726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53727 if (!SWIG_IsOK(res1)) {
53728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53729 }
53730 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53731 {
53732 PyThreadState* __tstate = wxPyBeginAllowThreads();
53733 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
53734 wxPyEndAllowThreads(__tstate);
53735 if (PyErr_Occurred()) SWIG_fail;
53736 }
53737 {
53738 resultobj = wxPyMake_wxObject(result, (bool)0);
53739 }
53740 return resultobj;
53741 fail:
53742 return NULL;
53743 }
53744
53745
53746 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53747 PyObject *resultobj = 0;
53748 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53749 wxButton *result = 0 ;
53750 void *argp1 = 0 ;
53751 int res1 = 0 ;
53752 PyObject *swig_obj[1] ;
53753
53754 if (!args) SWIG_fail;
53755 swig_obj[0] = args;
53756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53757 if (!SWIG_IsOK(res1)) {
53758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53759 }
53760 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53761 {
53762 PyThreadState* __tstate = wxPyBeginAllowThreads();
53763 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
53764 wxPyEndAllowThreads(__tstate);
53765 if (PyErr_Occurred()) SWIG_fail;
53766 }
53767 {
53768 resultobj = wxPyMake_wxObject(result, (bool)0);
53769 }
53770 return resultobj;
53771 fail:
53772 return NULL;
53773 }
53774
53775
53776 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53777 PyObject *obj;
53778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53779 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
53780 return SWIG_Py_Void();
53781 }
53782
53783 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53784 return SWIG_Python_InitShadowInstance(args);
53785 }
53786
53787 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53788 PyObject *resultobj = 0;
53789 int arg1 = (int) 0 ;
53790 int arg2 = (int) 0 ;
53791 wxGBPosition *result = 0 ;
53792 int val1 ;
53793 int ecode1 = 0 ;
53794 int val2 ;
53795 int ecode2 = 0 ;
53796 PyObject * obj0 = 0 ;
53797 PyObject * obj1 = 0 ;
53798 char * kwnames[] = {
53799 (char *) "row",(char *) "col", NULL
53800 };
53801
53802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
53803 if (obj0) {
53804 ecode1 = SWIG_AsVal_int(obj0, &val1);
53805 if (!SWIG_IsOK(ecode1)) {
53806 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
53807 }
53808 arg1 = static_cast< int >(val1);
53809 }
53810 if (obj1) {
53811 ecode2 = SWIG_AsVal_int(obj1, &val2);
53812 if (!SWIG_IsOK(ecode2)) {
53813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
53814 }
53815 arg2 = static_cast< int >(val2);
53816 }
53817 {
53818 PyThreadState* __tstate = wxPyBeginAllowThreads();
53819 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
53820 wxPyEndAllowThreads(__tstate);
53821 if (PyErr_Occurred()) SWIG_fail;
53822 }
53823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
53824 return resultobj;
53825 fail:
53826 return NULL;
53827 }
53828
53829
53830 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53831 PyObject *resultobj = 0;
53832 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53833 void *argp1 = 0 ;
53834 int res1 = 0 ;
53835 PyObject *swig_obj[1] ;
53836
53837 if (!args) SWIG_fail;
53838 swig_obj[0] = args;
53839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
53840 if (!SWIG_IsOK(res1)) {
53841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53842 }
53843 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53844 {
53845 PyThreadState* __tstate = wxPyBeginAllowThreads();
53846 delete arg1;
53847
53848 wxPyEndAllowThreads(__tstate);
53849 if (PyErr_Occurred()) SWIG_fail;
53850 }
53851 resultobj = SWIG_Py_Void();
53852 return resultobj;
53853 fail:
53854 return NULL;
53855 }
53856
53857
53858 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53859 PyObject *resultobj = 0;
53860 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53861 int result;
53862 void *argp1 = 0 ;
53863 int res1 = 0 ;
53864 PyObject *swig_obj[1] ;
53865
53866 if (!args) SWIG_fail;
53867 swig_obj[0] = args;
53868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53869 if (!SWIG_IsOK(res1)) {
53870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
53871 }
53872 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53873 {
53874 PyThreadState* __tstate = wxPyBeginAllowThreads();
53875 result = (int)((wxGBPosition const *)arg1)->GetRow();
53876 wxPyEndAllowThreads(__tstate);
53877 if (PyErr_Occurred()) SWIG_fail;
53878 }
53879 resultobj = SWIG_From_int(static_cast< int >(result));
53880 return resultobj;
53881 fail:
53882 return NULL;
53883 }
53884
53885
53886 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53887 PyObject *resultobj = 0;
53888 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53889 int result;
53890 void *argp1 = 0 ;
53891 int res1 = 0 ;
53892 PyObject *swig_obj[1] ;
53893
53894 if (!args) SWIG_fail;
53895 swig_obj[0] = args;
53896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53897 if (!SWIG_IsOK(res1)) {
53898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
53899 }
53900 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53901 {
53902 PyThreadState* __tstate = wxPyBeginAllowThreads();
53903 result = (int)((wxGBPosition const *)arg1)->GetCol();
53904 wxPyEndAllowThreads(__tstate);
53905 if (PyErr_Occurred()) SWIG_fail;
53906 }
53907 resultobj = SWIG_From_int(static_cast< int >(result));
53908 return resultobj;
53909 fail:
53910 return NULL;
53911 }
53912
53913
53914 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53915 PyObject *resultobj = 0;
53916 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53917 int arg2 ;
53918 void *argp1 = 0 ;
53919 int res1 = 0 ;
53920 int val2 ;
53921 int ecode2 = 0 ;
53922 PyObject * obj0 = 0 ;
53923 PyObject * obj1 = 0 ;
53924 char * kwnames[] = {
53925 (char *) "self",(char *) "row", NULL
53926 };
53927
53928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
53929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53930 if (!SWIG_IsOK(res1)) {
53931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53932 }
53933 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53934 ecode2 = SWIG_AsVal_int(obj1, &val2);
53935 if (!SWIG_IsOK(ecode2)) {
53936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
53937 }
53938 arg2 = static_cast< int >(val2);
53939 {
53940 PyThreadState* __tstate = wxPyBeginAllowThreads();
53941 (arg1)->SetRow(arg2);
53942 wxPyEndAllowThreads(__tstate);
53943 if (PyErr_Occurred()) SWIG_fail;
53944 }
53945 resultobj = SWIG_Py_Void();
53946 return resultobj;
53947 fail:
53948 return NULL;
53949 }
53950
53951
53952 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53953 PyObject *resultobj = 0;
53954 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53955 int arg2 ;
53956 void *argp1 = 0 ;
53957 int res1 = 0 ;
53958 int val2 ;
53959 int ecode2 = 0 ;
53960 PyObject * obj0 = 0 ;
53961 PyObject * obj1 = 0 ;
53962 char * kwnames[] = {
53963 (char *) "self",(char *) "col", NULL
53964 };
53965
53966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
53967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53968 if (!SWIG_IsOK(res1)) {
53969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53970 }
53971 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53972 ecode2 = SWIG_AsVal_int(obj1, &val2);
53973 if (!SWIG_IsOK(ecode2)) {
53974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
53975 }
53976 arg2 = static_cast< int >(val2);
53977 {
53978 PyThreadState* __tstate = wxPyBeginAllowThreads();
53979 (arg1)->SetCol(arg2);
53980 wxPyEndAllowThreads(__tstate);
53981 if (PyErr_Occurred()) SWIG_fail;
53982 }
53983 resultobj = SWIG_Py_Void();
53984 return resultobj;
53985 fail:
53986 return NULL;
53987 }
53988
53989
53990 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53991 PyObject *resultobj = 0;
53992 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53993 PyObject *arg2 = (PyObject *) 0 ;
53994 bool result;
53995 void *argp1 = 0 ;
53996 int res1 = 0 ;
53997 PyObject * obj0 = 0 ;
53998 PyObject * obj1 = 0 ;
53999 char * kwnames[] = {
54000 (char *) "self",(char *) "other", NULL
54001 };
54002
54003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54005 if (!SWIG_IsOK(res1)) {
54006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54007 }
54008 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54009 arg2 = obj1;
54010 {
54011 result = (bool)wxGBPosition___eq__(arg1,arg2);
54012 if (PyErr_Occurred()) SWIG_fail;
54013 }
54014 {
54015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54016 }
54017 return resultobj;
54018 fail:
54019 return NULL;
54020 }
54021
54022
54023 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54024 PyObject *resultobj = 0;
54025 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54026 PyObject *arg2 = (PyObject *) 0 ;
54027 bool result;
54028 void *argp1 = 0 ;
54029 int res1 = 0 ;
54030 PyObject * obj0 = 0 ;
54031 PyObject * obj1 = 0 ;
54032 char * kwnames[] = {
54033 (char *) "self",(char *) "other", NULL
54034 };
54035
54036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54038 if (!SWIG_IsOK(res1)) {
54039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54040 }
54041 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54042 arg2 = obj1;
54043 {
54044 result = (bool)wxGBPosition___ne__(arg1,arg2);
54045 if (PyErr_Occurred()) SWIG_fail;
54046 }
54047 {
54048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54049 }
54050 return resultobj;
54051 fail:
54052 return NULL;
54053 }
54054
54055
54056 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54057 PyObject *resultobj = 0;
54058 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54059 int arg2 = (int) 0 ;
54060 int arg3 = (int) 0 ;
54061 void *argp1 = 0 ;
54062 int res1 = 0 ;
54063 int val2 ;
54064 int ecode2 = 0 ;
54065 int val3 ;
54066 int ecode3 = 0 ;
54067 PyObject * obj0 = 0 ;
54068 PyObject * obj1 = 0 ;
54069 PyObject * obj2 = 0 ;
54070 char * kwnames[] = {
54071 (char *) "self",(char *) "row",(char *) "col", NULL
54072 };
54073
54074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54076 if (!SWIG_IsOK(res1)) {
54077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54078 }
54079 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54080 if (obj1) {
54081 ecode2 = SWIG_AsVal_int(obj1, &val2);
54082 if (!SWIG_IsOK(ecode2)) {
54083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54084 }
54085 arg2 = static_cast< int >(val2);
54086 }
54087 if (obj2) {
54088 ecode3 = SWIG_AsVal_int(obj2, &val3);
54089 if (!SWIG_IsOK(ecode3)) {
54090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54091 }
54092 arg3 = static_cast< int >(val3);
54093 }
54094 {
54095 PyThreadState* __tstate = wxPyBeginAllowThreads();
54096 wxGBPosition_Set(arg1,arg2,arg3);
54097 wxPyEndAllowThreads(__tstate);
54098 if (PyErr_Occurred()) SWIG_fail;
54099 }
54100 resultobj = SWIG_Py_Void();
54101 return resultobj;
54102 fail:
54103 return NULL;
54104 }
54105
54106
54107 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54108 PyObject *resultobj = 0;
54109 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54110 PyObject *result = 0 ;
54111 void *argp1 = 0 ;
54112 int res1 = 0 ;
54113 PyObject *swig_obj[1] ;
54114
54115 if (!args) SWIG_fail;
54116 swig_obj[0] = args;
54117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54118 if (!SWIG_IsOK(res1)) {
54119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54120 }
54121 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54122 {
54123 PyThreadState* __tstate = wxPyBeginAllowThreads();
54124 result = (PyObject *)wxGBPosition_Get(arg1);
54125 wxPyEndAllowThreads(__tstate);
54126 if (PyErr_Occurred()) SWIG_fail;
54127 }
54128 resultobj = result;
54129 return resultobj;
54130 fail:
54131 return NULL;
54132 }
54133
54134
54135 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54136 PyObject *obj;
54137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54138 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54139 return SWIG_Py_Void();
54140 }
54141
54142 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54143 return SWIG_Python_InitShadowInstance(args);
54144 }
54145
54146 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54147 PyObject *resultobj = 0;
54148 int arg1 = (int) 1 ;
54149 int arg2 = (int) 1 ;
54150 wxGBSpan *result = 0 ;
54151 int val1 ;
54152 int ecode1 = 0 ;
54153 int val2 ;
54154 int ecode2 = 0 ;
54155 PyObject * obj0 = 0 ;
54156 PyObject * obj1 = 0 ;
54157 char * kwnames[] = {
54158 (char *) "rowspan",(char *) "colspan", NULL
54159 };
54160
54161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54162 if (obj0) {
54163 ecode1 = SWIG_AsVal_int(obj0, &val1);
54164 if (!SWIG_IsOK(ecode1)) {
54165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54166 }
54167 arg1 = static_cast< int >(val1);
54168 }
54169 if (obj1) {
54170 ecode2 = SWIG_AsVal_int(obj1, &val2);
54171 if (!SWIG_IsOK(ecode2)) {
54172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54173 }
54174 arg2 = static_cast< int >(val2);
54175 }
54176 {
54177 PyThreadState* __tstate = wxPyBeginAllowThreads();
54178 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54179 wxPyEndAllowThreads(__tstate);
54180 if (PyErr_Occurred()) SWIG_fail;
54181 }
54182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54183 return resultobj;
54184 fail:
54185 return NULL;
54186 }
54187
54188
54189 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54190 PyObject *resultobj = 0;
54191 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54192 void *argp1 = 0 ;
54193 int res1 = 0 ;
54194 PyObject *swig_obj[1] ;
54195
54196 if (!args) SWIG_fail;
54197 swig_obj[0] = args;
54198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54199 if (!SWIG_IsOK(res1)) {
54200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54201 }
54202 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54203 {
54204 PyThreadState* __tstate = wxPyBeginAllowThreads();
54205 delete arg1;
54206
54207 wxPyEndAllowThreads(__tstate);
54208 if (PyErr_Occurred()) SWIG_fail;
54209 }
54210 resultobj = SWIG_Py_Void();
54211 return resultobj;
54212 fail:
54213 return NULL;
54214 }
54215
54216
54217 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54218 PyObject *resultobj = 0;
54219 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54220 int result;
54221 void *argp1 = 0 ;
54222 int res1 = 0 ;
54223 PyObject *swig_obj[1] ;
54224
54225 if (!args) SWIG_fail;
54226 swig_obj[0] = args;
54227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54228 if (!SWIG_IsOK(res1)) {
54229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54230 }
54231 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54232 {
54233 PyThreadState* __tstate = wxPyBeginAllowThreads();
54234 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54235 wxPyEndAllowThreads(__tstate);
54236 if (PyErr_Occurred()) SWIG_fail;
54237 }
54238 resultobj = SWIG_From_int(static_cast< int >(result));
54239 return resultobj;
54240 fail:
54241 return NULL;
54242 }
54243
54244
54245 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54246 PyObject *resultobj = 0;
54247 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54248 int result;
54249 void *argp1 = 0 ;
54250 int res1 = 0 ;
54251 PyObject *swig_obj[1] ;
54252
54253 if (!args) SWIG_fail;
54254 swig_obj[0] = args;
54255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54256 if (!SWIG_IsOK(res1)) {
54257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54258 }
54259 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54260 {
54261 PyThreadState* __tstate = wxPyBeginAllowThreads();
54262 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54263 wxPyEndAllowThreads(__tstate);
54264 if (PyErr_Occurred()) SWIG_fail;
54265 }
54266 resultobj = SWIG_From_int(static_cast< int >(result));
54267 return resultobj;
54268 fail:
54269 return NULL;
54270 }
54271
54272
54273 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54274 PyObject *resultobj = 0;
54275 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54276 int arg2 ;
54277 void *argp1 = 0 ;
54278 int res1 = 0 ;
54279 int val2 ;
54280 int ecode2 = 0 ;
54281 PyObject * obj0 = 0 ;
54282 PyObject * obj1 = 0 ;
54283 char * kwnames[] = {
54284 (char *) "self",(char *) "rowspan", NULL
54285 };
54286
54287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54289 if (!SWIG_IsOK(res1)) {
54290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54291 }
54292 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54293 ecode2 = SWIG_AsVal_int(obj1, &val2);
54294 if (!SWIG_IsOK(ecode2)) {
54295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54296 }
54297 arg2 = static_cast< int >(val2);
54298 {
54299 PyThreadState* __tstate = wxPyBeginAllowThreads();
54300 (arg1)->SetRowspan(arg2);
54301 wxPyEndAllowThreads(__tstate);
54302 if (PyErr_Occurred()) SWIG_fail;
54303 }
54304 resultobj = SWIG_Py_Void();
54305 return resultobj;
54306 fail:
54307 return NULL;
54308 }
54309
54310
54311 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54312 PyObject *resultobj = 0;
54313 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54314 int arg2 ;
54315 void *argp1 = 0 ;
54316 int res1 = 0 ;
54317 int val2 ;
54318 int ecode2 = 0 ;
54319 PyObject * obj0 = 0 ;
54320 PyObject * obj1 = 0 ;
54321 char * kwnames[] = {
54322 (char *) "self",(char *) "colspan", NULL
54323 };
54324
54325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
54326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54327 if (!SWIG_IsOK(res1)) {
54328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54329 }
54330 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54331 ecode2 = SWIG_AsVal_int(obj1, &val2);
54332 if (!SWIG_IsOK(ecode2)) {
54333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
54334 }
54335 arg2 = static_cast< int >(val2);
54336 {
54337 PyThreadState* __tstate = wxPyBeginAllowThreads();
54338 (arg1)->SetColspan(arg2);
54339 wxPyEndAllowThreads(__tstate);
54340 if (PyErr_Occurred()) SWIG_fail;
54341 }
54342 resultobj = SWIG_Py_Void();
54343 return resultobj;
54344 fail:
54345 return NULL;
54346 }
54347
54348
54349 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54350 PyObject *resultobj = 0;
54351 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54352 PyObject *arg2 = (PyObject *) 0 ;
54353 bool result;
54354 void *argp1 = 0 ;
54355 int res1 = 0 ;
54356 PyObject * obj0 = 0 ;
54357 PyObject * obj1 = 0 ;
54358 char * kwnames[] = {
54359 (char *) "self",(char *) "other", NULL
54360 };
54361
54362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54364 if (!SWIG_IsOK(res1)) {
54365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54366 }
54367 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54368 arg2 = obj1;
54369 {
54370 result = (bool)wxGBSpan___eq__(arg1,arg2);
54371 if (PyErr_Occurred()) SWIG_fail;
54372 }
54373 {
54374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54375 }
54376 return resultobj;
54377 fail:
54378 return NULL;
54379 }
54380
54381
54382 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54383 PyObject *resultobj = 0;
54384 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54385 PyObject *arg2 = (PyObject *) 0 ;
54386 bool result;
54387 void *argp1 = 0 ;
54388 int res1 = 0 ;
54389 PyObject * obj0 = 0 ;
54390 PyObject * obj1 = 0 ;
54391 char * kwnames[] = {
54392 (char *) "self",(char *) "other", NULL
54393 };
54394
54395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54397 if (!SWIG_IsOK(res1)) {
54398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54399 }
54400 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54401 arg2 = obj1;
54402 {
54403 result = (bool)wxGBSpan___ne__(arg1,arg2);
54404 if (PyErr_Occurred()) SWIG_fail;
54405 }
54406 {
54407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54408 }
54409 return resultobj;
54410 fail:
54411 return NULL;
54412 }
54413
54414
54415 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54416 PyObject *resultobj = 0;
54417 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54418 int arg2 = (int) 1 ;
54419 int arg3 = (int) 1 ;
54420 void *argp1 = 0 ;
54421 int res1 = 0 ;
54422 int val2 ;
54423 int ecode2 = 0 ;
54424 int val3 ;
54425 int ecode3 = 0 ;
54426 PyObject * obj0 = 0 ;
54427 PyObject * obj1 = 0 ;
54428 PyObject * obj2 = 0 ;
54429 char * kwnames[] = {
54430 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
54431 };
54432
54433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54435 if (!SWIG_IsOK(res1)) {
54436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54437 }
54438 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54439 if (obj1) {
54440 ecode2 = SWIG_AsVal_int(obj1, &val2);
54441 if (!SWIG_IsOK(ecode2)) {
54442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
54443 }
54444 arg2 = static_cast< int >(val2);
54445 }
54446 if (obj2) {
54447 ecode3 = SWIG_AsVal_int(obj2, &val3);
54448 if (!SWIG_IsOK(ecode3)) {
54449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
54450 }
54451 arg3 = static_cast< int >(val3);
54452 }
54453 {
54454 PyThreadState* __tstate = wxPyBeginAllowThreads();
54455 wxGBSpan_Set(arg1,arg2,arg3);
54456 wxPyEndAllowThreads(__tstate);
54457 if (PyErr_Occurred()) SWIG_fail;
54458 }
54459 resultobj = SWIG_Py_Void();
54460 return resultobj;
54461 fail:
54462 return NULL;
54463 }
54464
54465
54466 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54467 PyObject *resultobj = 0;
54468 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54469 PyObject *result = 0 ;
54470 void *argp1 = 0 ;
54471 int res1 = 0 ;
54472 PyObject *swig_obj[1] ;
54473
54474 if (!args) SWIG_fail;
54475 swig_obj[0] = args;
54476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54477 if (!SWIG_IsOK(res1)) {
54478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54479 }
54480 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54481 {
54482 PyThreadState* __tstate = wxPyBeginAllowThreads();
54483 result = (PyObject *)wxGBSpan_Get(arg1);
54484 wxPyEndAllowThreads(__tstate);
54485 if (PyErr_Occurred()) SWIG_fail;
54486 }
54487 resultobj = result;
54488 return resultobj;
54489 fail:
54490 return NULL;
54491 }
54492
54493
54494 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54495 PyObject *obj;
54496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54497 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
54498 return SWIG_Py_Void();
54499 }
54500
54501 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54502 return SWIG_Python_InitShadowInstance(args);
54503 }
54504
54505 SWIGINTERN int DefaultSpan_set(PyObject *) {
54506 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
54507 return 1;
54508 }
54509
54510
54511 SWIGINTERN PyObject *DefaultSpan_get(void) {
54512 PyObject *pyobj = 0;
54513
54514 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
54515 return pyobj;
54516 }
54517
54518
54519 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54520 PyObject *resultobj = 0;
54521 wxGBSizerItem *result = 0 ;
54522
54523 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
54524 {
54525 PyThreadState* __tstate = wxPyBeginAllowThreads();
54526 result = (wxGBSizerItem *)new wxGBSizerItem();
54527 wxPyEndAllowThreads(__tstate);
54528 if (PyErr_Occurred()) SWIG_fail;
54529 }
54530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
54531 return resultobj;
54532 fail:
54533 return NULL;
54534 }
54535
54536
54537 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54538 PyObject *resultobj = 0;
54539 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54540 void *argp1 = 0 ;
54541 int res1 = 0 ;
54542 PyObject *swig_obj[1] ;
54543
54544 if (!args) SWIG_fail;
54545 swig_obj[0] = args;
54546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54547 if (!SWIG_IsOK(res1)) {
54548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54549 }
54550 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54551 {
54552 PyThreadState* __tstate = wxPyBeginAllowThreads();
54553 delete arg1;
54554
54555 wxPyEndAllowThreads(__tstate);
54556 if (PyErr_Occurred()) SWIG_fail;
54557 }
54558 resultobj = SWIG_Py_Void();
54559 return resultobj;
54560 fail:
54561 return NULL;
54562 }
54563
54564
54565 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54566 PyObject *resultobj = 0;
54567 wxWindow *arg1 = (wxWindow *) 0 ;
54568 wxGBPosition *arg2 = 0 ;
54569 wxGBSpan *arg3 = 0 ;
54570 int arg4 ;
54571 int arg5 ;
54572 PyObject *arg6 = (PyObject *) NULL ;
54573 wxGBSizerItem *result = 0 ;
54574 void *argp1 = 0 ;
54575 int res1 = 0 ;
54576 wxGBPosition temp2 ;
54577 wxGBSpan temp3 ;
54578 int val4 ;
54579 int ecode4 = 0 ;
54580 int val5 ;
54581 int ecode5 = 0 ;
54582 PyObject * obj0 = 0 ;
54583 PyObject * obj1 = 0 ;
54584 PyObject * obj2 = 0 ;
54585 PyObject * obj3 = 0 ;
54586 PyObject * obj4 = 0 ;
54587 PyObject * obj5 = 0 ;
54588 char * kwnames[] = {
54589 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54590 };
54591
54592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
54594 if (!SWIG_IsOK(res1)) {
54595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
54596 }
54597 arg1 = reinterpret_cast< wxWindow * >(argp1);
54598 {
54599 arg2 = &temp2;
54600 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54601 }
54602 {
54603 arg3 = &temp3;
54604 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54605 }
54606 ecode4 = SWIG_AsVal_int(obj3, &val4);
54607 if (!SWIG_IsOK(ecode4)) {
54608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
54609 }
54610 arg4 = static_cast< int >(val4);
54611 ecode5 = SWIG_AsVal_int(obj4, &val5);
54612 if (!SWIG_IsOK(ecode5)) {
54613 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
54614 }
54615 arg5 = static_cast< int >(val5);
54616 if (obj5) {
54617 arg6 = obj5;
54618 }
54619 {
54620 PyThreadState* __tstate = wxPyBeginAllowThreads();
54621 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54622 wxPyEndAllowThreads(__tstate);
54623 if (PyErr_Occurred()) SWIG_fail;
54624 }
54625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54626 return resultobj;
54627 fail:
54628 return NULL;
54629 }
54630
54631
54632 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54633 PyObject *resultobj = 0;
54634 wxSizer *arg1 = (wxSizer *) 0 ;
54635 wxGBPosition *arg2 = 0 ;
54636 wxGBSpan *arg3 = 0 ;
54637 int arg4 ;
54638 int arg5 ;
54639 PyObject *arg6 = (PyObject *) NULL ;
54640 wxGBSizerItem *result = 0 ;
54641 int res1 = 0 ;
54642 wxGBPosition temp2 ;
54643 wxGBSpan temp3 ;
54644 int val4 ;
54645 int ecode4 = 0 ;
54646 int val5 ;
54647 int ecode5 = 0 ;
54648 PyObject * obj0 = 0 ;
54649 PyObject * obj1 = 0 ;
54650 PyObject * obj2 = 0 ;
54651 PyObject * obj3 = 0 ;
54652 PyObject * obj4 = 0 ;
54653 PyObject * obj5 = 0 ;
54654 char * kwnames[] = {
54655 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54656 };
54657
54658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54659 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
54660 if (!SWIG_IsOK(res1)) {
54661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
54662 }
54663 {
54664 arg2 = &temp2;
54665 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54666 }
54667 {
54668 arg3 = &temp3;
54669 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54670 }
54671 ecode4 = SWIG_AsVal_int(obj3, &val4);
54672 if (!SWIG_IsOK(ecode4)) {
54673 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
54674 }
54675 arg4 = static_cast< int >(val4);
54676 ecode5 = SWIG_AsVal_int(obj4, &val5);
54677 if (!SWIG_IsOK(ecode5)) {
54678 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
54679 }
54680 arg5 = static_cast< int >(val5);
54681 if (obj5) {
54682 arg6 = obj5;
54683 }
54684 {
54685 PyThreadState* __tstate = wxPyBeginAllowThreads();
54686 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54687 wxPyEndAllowThreads(__tstate);
54688 if (PyErr_Occurred()) SWIG_fail;
54689 }
54690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54691 return resultobj;
54692 fail:
54693 return NULL;
54694 }
54695
54696
54697 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54698 PyObject *resultobj = 0;
54699 int arg1 ;
54700 int arg2 ;
54701 wxGBPosition *arg3 = 0 ;
54702 wxGBSpan *arg4 = 0 ;
54703 int arg5 ;
54704 int arg6 ;
54705 PyObject *arg7 = (PyObject *) NULL ;
54706 wxGBSizerItem *result = 0 ;
54707 int val1 ;
54708 int ecode1 = 0 ;
54709 int val2 ;
54710 int ecode2 = 0 ;
54711 wxGBPosition temp3 ;
54712 wxGBSpan temp4 ;
54713 int val5 ;
54714 int ecode5 = 0 ;
54715 int val6 ;
54716 int ecode6 = 0 ;
54717 PyObject * obj0 = 0 ;
54718 PyObject * obj1 = 0 ;
54719 PyObject * obj2 = 0 ;
54720 PyObject * obj3 = 0 ;
54721 PyObject * obj4 = 0 ;
54722 PyObject * obj5 = 0 ;
54723 PyObject * obj6 = 0 ;
54724 char * kwnames[] = {
54725 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54726 };
54727
54728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54729 ecode1 = SWIG_AsVal_int(obj0, &val1);
54730 if (!SWIG_IsOK(ecode1)) {
54731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
54732 }
54733 arg1 = static_cast< int >(val1);
54734 ecode2 = SWIG_AsVal_int(obj1, &val2);
54735 if (!SWIG_IsOK(ecode2)) {
54736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
54737 }
54738 arg2 = static_cast< int >(val2);
54739 {
54740 arg3 = &temp3;
54741 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54742 }
54743 {
54744 arg4 = &temp4;
54745 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54746 }
54747 ecode5 = SWIG_AsVal_int(obj4, &val5);
54748 if (!SWIG_IsOK(ecode5)) {
54749 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
54750 }
54751 arg5 = static_cast< int >(val5);
54752 ecode6 = SWIG_AsVal_int(obj5, &val6);
54753 if (!SWIG_IsOK(ecode6)) {
54754 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
54755 }
54756 arg6 = static_cast< int >(val6);
54757 if (obj6) {
54758 arg7 = obj6;
54759 }
54760 {
54761 PyThreadState* __tstate = wxPyBeginAllowThreads();
54762 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54763 wxPyEndAllowThreads(__tstate);
54764 if (PyErr_Occurred()) SWIG_fail;
54765 }
54766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54767 return resultobj;
54768 fail:
54769 return NULL;
54770 }
54771
54772
54773 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54774 PyObject *resultobj = 0;
54775 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54776 wxGBPosition result;
54777 void *argp1 = 0 ;
54778 int res1 = 0 ;
54779 PyObject *swig_obj[1] ;
54780
54781 if (!args) SWIG_fail;
54782 swig_obj[0] = args;
54783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54784 if (!SWIG_IsOK(res1)) {
54785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54786 }
54787 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54788 {
54789 PyThreadState* __tstate = wxPyBeginAllowThreads();
54790 result = ((wxGBSizerItem const *)arg1)->GetPos();
54791 wxPyEndAllowThreads(__tstate);
54792 if (PyErr_Occurred()) SWIG_fail;
54793 }
54794 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54795 return resultobj;
54796 fail:
54797 return NULL;
54798 }
54799
54800
54801 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54802 PyObject *resultobj = 0;
54803 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54804 wxGBSpan result;
54805 void *argp1 = 0 ;
54806 int res1 = 0 ;
54807 PyObject *swig_obj[1] ;
54808
54809 if (!args) SWIG_fail;
54810 swig_obj[0] = args;
54811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54812 if (!SWIG_IsOK(res1)) {
54813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54814 }
54815 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54816 {
54817 PyThreadState* __tstate = wxPyBeginAllowThreads();
54818 result = ((wxGBSizerItem const *)arg1)->GetSpan();
54819 wxPyEndAllowThreads(__tstate);
54820 if (PyErr_Occurred()) SWIG_fail;
54821 }
54822 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54823 return resultobj;
54824 fail:
54825 return NULL;
54826 }
54827
54828
54829 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54830 PyObject *resultobj = 0;
54831 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54832 wxGBPosition *arg2 = 0 ;
54833 bool result;
54834 void *argp1 = 0 ;
54835 int res1 = 0 ;
54836 wxGBPosition temp2 ;
54837 PyObject * obj0 = 0 ;
54838 PyObject * obj1 = 0 ;
54839 char * kwnames[] = {
54840 (char *) "self",(char *) "pos", NULL
54841 };
54842
54843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
54844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54845 if (!SWIG_IsOK(res1)) {
54846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54847 }
54848 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54849 {
54850 arg2 = &temp2;
54851 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54852 }
54853 {
54854 PyThreadState* __tstate = wxPyBeginAllowThreads();
54855 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
54856 wxPyEndAllowThreads(__tstate);
54857 if (PyErr_Occurred()) SWIG_fail;
54858 }
54859 {
54860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54861 }
54862 return resultobj;
54863 fail:
54864 return NULL;
54865 }
54866
54867
54868 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54869 PyObject *resultobj = 0;
54870 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54871 wxGBSpan *arg2 = 0 ;
54872 bool result;
54873 void *argp1 = 0 ;
54874 int res1 = 0 ;
54875 wxGBSpan temp2 ;
54876 PyObject * obj0 = 0 ;
54877 PyObject * obj1 = 0 ;
54878 char * kwnames[] = {
54879 (char *) "self",(char *) "span", NULL
54880 };
54881
54882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54884 if (!SWIG_IsOK(res1)) {
54885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54886 }
54887 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54888 {
54889 arg2 = &temp2;
54890 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
54891 }
54892 {
54893 PyThreadState* __tstate = wxPyBeginAllowThreads();
54894 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
54895 wxPyEndAllowThreads(__tstate);
54896 if (PyErr_Occurred()) SWIG_fail;
54897 }
54898 {
54899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54900 }
54901 return resultobj;
54902 fail:
54903 return NULL;
54904 }
54905
54906
54907 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54908 PyObject *resultobj = 0;
54909 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54910 wxGBSizerItem *arg2 = 0 ;
54911 bool result;
54912 void *argp1 = 0 ;
54913 int res1 = 0 ;
54914 void *argp2 = 0 ;
54915 int res2 = 0 ;
54916 PyObject * obj0 = 0 ;
54917 PyObject * obj1 = 0 ;
54918 char * kwnames[] = {
54919 (char *) "self",(char *) "other", NULL
54920 };
54921
54922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
54923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54924 if (!SWIG_IsOK(res1)) {
54925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54926 }
54927 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
54929 if (!SWIG_IsOK(res2)) {
54930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
54931 }
54932 if (!argp2) {
54933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
54934 }
54935 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54936 {
54937 PyThreadState* __tstate = wxPyBeginAllowThreads();
54938 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
54939 wxPyEndAllowThreads(__tstate);
54940 if (PyErr_Occurred()) SWIG_fail;
54941 }
54942 {
54943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54944 }
54945 return resultobj;
54946 fail:
54947 return NULL;
54948 }
54949
54950
54951 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54952 PyObject *resultobj = 0;
54953 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54954 wxGBPosition *arg2 = 0 ;
54955 wxGBSpan *arg3 = 0 ;
54956 bool result;
54957 void *argp1 = 0 ;
54958 int res1 = 0 ;
54959 wxGBPosition temp2 ;
54960 wxGBSpan temp3 ;
54961 PyObject * obj0 = 0 ;
54962 PyObject * obj1 = 0 ;
54963 PyObject * obj2 = 0 ;
54964 char * kwnames[] = {
54965 (char *) "self",(char *) "pos",(char *) "span", NULL
54966 };
54967
54968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54970 if (!SWIG_IsOK(res1)) {
54971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54972 }
54973 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54974 {
54975 arg2 = &temp2;
54976 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54977 }
54978 {
54979 arg3 = &temp3;
54980 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54981 }
54982 {
54983 PyThreadState* __tstate = wxPyBeginAllowThreads();
54984 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
54985 wxPyEndAllowThreads(__tstate);
54986 if (PyErr_Occurred()) SWIG_fail;
54987 }
54988 {
54989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54990 }
54991 return resultobj;
54992 fail:
54993 return NULL;
54994 }
54995
54996
54997 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54998 PyObject *resultobj = 0;
54999 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55000 wxGBPosition result;
55001 void *argp1 = 0 ;
55002 int res1 = 0 ;
55003 PyObject *swig_obj[1] ;
55004
55005 if (!args) SWIG_fail;
55006 swig_obj[0] = args;
55007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55008 if (!SWIG_IsOK(res1)) {
55009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55010 }
55011 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55012 {
55013 PyThreadState* __tstate = wxPyBeginAllowThreads();
55014 result = wxGBSizerItem_GetEndPos(arg1);
55015 wxPyEndAllowThreads(__tstate);
55016 if (PyErr_Occurred()) SWIG_fail;
55017 }
55018 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55019 return resultobj;
55020 fail:
55021 return NULL;
55022 }
55023
55024
55025 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55026 PyObject *resultobj = 0;
55027 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55028 wxGridBagSizer *result = 0 ;
55029 void *argp1 = 0 ;
55030 int res1 = 0 ;
55031 PyObject *swig_obj[1] ;
55032
55033 if (!args) SWIG_fail;
55034 swig_obj[0] = args;
55035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55036 if (!SWIG_IsOK(res1)) {
55037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55038 }
55039 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55040 {
55041 PyThreadState* __tstate = wxPyBeginAllowThreads();
55042 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55043 wxPyEndAllowThreads(__tstate);
55044 if (PyErr_Occurred()) SWIG_fail;
55045 }
55046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55047 return resultobj;
55048 fail:
55049 return NULL;
55050 }
55051
55052
55053 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55054 PyObject *resultobj = 0;
55055 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55056 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55057 void *argp1 = 0 ;
55058 int res1 = 0 ;
55059 void *argp2 = 0 ;
55060 int res2 = 0 ;
55061 PyObject * obj0 = 0 ;
55062 PyObject * obj1 = 0 ;
55063 char * kwnames[] = {
55064 (char *) "self",(char *) "sizer", NULL
55065 };
55066
55067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55069 if (!SWIG_IsOK(res1)) {
55070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55071 }
55072 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55074 if (!SWIG_IsOK(res2)) {
55075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55076 }
55077 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55078 {
55079 PyThreadState* __tstate = wxPyBeginAllowThreads();
55080 (arg1)->SetGBSizer(arg2);
55081 wxPyEndAllowThreads(__tstate);
55082 if (PyErr_Occurred()) SWIG_fail;
55083 }
55084 resultobj = SWIG_Py_Void();
55085 return resultobj;
55086 fail:
55087 return NULL;
55088 }
55089
55090
55091 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55092 PyObject *obj;
55093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55094 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55095 return SWIG_Py_Void();
55096 }
55097
55098 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55099 return SWIG_Python_InitShadowInstance(args);
55100 }
55101
55102 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55103 PyObject *resultobj = 0;
55104 int arg1 = (int) 0 ;
55105 int arg2 = (int) 0 ;
55106 wxGridBagSizer *result = 0 ;
55107 int val1 ;
55108 int ecode1 = 0 ;
55109 int val2 ;
55110 int ecode2 = 0 ;
55111 PyObject * obj0 = 0 ;
55112 PyObject * obj1 = 0 ;
55113 char * kwnames[] = {
55114 (char *) "vgap",(char *) "hgap", NULL
55115 };
55116
55117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55118 if (obj0) {
55119 ecode1 = SWIG_AsVal_int(obj0, &val1);
55120 if (!SWIG_IsOK(ecode1)) {
55121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55122 }
55123 arg1 = static_cast< int >(val1);
55124 }
55125 if (obj1) {
55126 ecode2 = SWIG_AsVal_int(obj1, &val2);
55127 if (!SWIG_IsOK(ecode2)) {
55128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55129 }
55130 arg2 = static_cast< int >(val2);
55131 }
55132 {
55133 PyThreadState* __tstate = wxPyBeginAllowThreads();
55134 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55135 wxPyEndAllowThreads(__tstate);
55136 if (PyErr_Occurred()) SWIG_fail;
55137 }
55138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55139 return resultobj;
55140 fail:
55141 return NULL;
55142 }
55143
55144
55145 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55146 PyObject *resultobj = 0;
55147 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55148 PyObject *arg2 = (PyObject *) 0 ;
55149 wxGBPosition *arg3 = 0 ;
55150 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55151 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55152 int arg5 = (int) 0 ;
55153 int arg6 = (int) 0 ;
55154 PyObject *arg7 = (PyObject *) NULL ;
55155 wxGBSizerItem *result = 0 ;
55156 void *argp1 = 0 ;
55157 int res1 = 0 ;
55158 wxGBPosition temp3 ;
55159 wxGBSpan temp4 ;
55160 int val5 ;
55161 int ecode5 = 0 ;
55162 int val6 ;
55163 int ecode6 = 0 ;
55164 PyObject * obj0 = 0 ;
55165 PyObject * obj1 = 0 ;
55166 PyObject * obj2 = 0 ;
55167 PyObject * obj3 = 0 ;
55168 PyObject * obj4 = 0 ;
55169 PyObject * obj5 = 0 ;
55170 PyObject * obj6 = 0 ;
55171 char * kwnames[] = {
55172 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55173 };
55174
55175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55177 if (!SWIG_IsOK(res1)) {
55178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55179 }
55180 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55181 arg2 = obj1;
55182 {
55183 arg3 = &temp3;
55184 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55185 }
55186 if (obj3) {
55187 {
55188 arg4 = &temp4;
55189 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55190 }
55191 }
55192 if (obj4) {
55193 ecode5 = SWIG_AsVal_int(obj4, &val5);
55194 if (!SWIG_IsOK(ecode5)) {
55195 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55196 }
55197 arg5 = static_cast< int >(val5);
55198 }
55199 if (obj5) {
55200 ecode6 = SWIG_AsVal_int(obj5, &val6);
55201 if (!SWIG_IsOK(ecode6)) {
55202 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55203 }
55204 arg6 = static_cast< int >(val6);
55205 }
55206 if (obj6) {
55207 arg7 = obj6;
55208 }
55209 {
55210 PyThreadState* __tstate = wxPyBeginAllowThreads();
55211 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55212 wxPyEndAllowThreads(__tstate);
55213 if (PyErr_Occurred()) SWIG_fail;
55214 }
55215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55216 return resultobj;
55217 fail:
55218 return NULL;
55219 }
55220
55221
55222 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55223 PyObject *resultobj = 0;
55224 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55225 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55226 wxGBSizerItem *result = 0 ;
55227 void *argp1 = 0 ;
55228 int res1 = 0 ;
55229 int res2 = 0 ;
55230 PyObject * obj0 = 0 ;
55231 PyObject * obj1 = 0 ;
55232 char * kwnames[] = {
55233 (char *) "self",(char *) "item", NULL
55234 };
55235
55236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55238 if (!SWIG_IsOK(res1)) {
55239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55240 }
55241 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55242 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55243 if (!SWIG_IsOK(res2)) {
55244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55245 }
55246 {
55247 PyThreadState* __tstate = wxPyBeginAllowThreads();
55248 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55249 wxPyEndAllowThreads(__tstate);
55250 if (PyErr_Occurred()) SWIG_fail;
55251 }
55252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55253 return resultobj;
55254 fail:
55255 return NULL;
55256 }
55257
55258
55259 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55260 PyObject *resultobj = 0;
55261 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55262 int arg2 ;
55263 int arg3 ;
55264 wxSize result;
55265 void *argp1 = 0 ;
55266 int res1 = 0 ;
55267 int val2 ;
55268 int ecode2 = 0 ;
55269 int val3 ;
55270 int ecode3 = 0 ;
55271 PyObject * obj0 = 0 ;
55272 PyObject * obj1 = 0 ;
55273 PyObject * obj2 = 0 ;
55274 char * kwnames[] = {
55275 (char *) "self",(char *) "row",(char *) "col", NULL
55276 };
55277
55278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) 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_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55282 }
55283 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55284 ecode2 = SWIG_AsVal_int(obj1, &val2);
55285 if (!SWIG_IsOK(ecode2)) {
55286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55287 }
55288 arg2 = static_cast< int >(val2);
55289 ecode3 = SWIG_AsVal_int(obj2, &val3);
55290 if (!SWIG_IsOK(ecode3)) {
55291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55292 }
55293 arg3 = static_cast< int >(val3);
55294 {
55295 PyThreadState* __tstate = wxPyBeginAllowThreads();
55296 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55297 wxPyEndAllowThreads(__tstate);
55298 if (PyErr_Occurred()) SWIG_fail;
55299 }
55300 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55301 return resultobj;
55302 fail:
55303 return NULL;
55304 }
55305
55306
55307 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55308 PyObject *resultobj = 0;
55309 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55310 wxSize result;
55311 void *argp1 = 0 ;
55312 int res1 = 0 ;
55313 PyObject *swig_obj[1] ;
55314
55315 if (!args) SWIG_fail;
55316 swig_obj[0] = args;
55317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55318 if (!SWIG_IsOK(res1)) {
55319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55320 }
55321 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55322 {
55323 PyThreadState* __tstate = wxPyBeginAllowThreads();
55324 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
55325 wxPyEndAllowThreads(__tstate);
55326 if (PyErr_Occurred()) SWIG_fail;
55327 }
55328 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55329 return resultobj;
55330 fail:
55331 return NULL;
55332 }
55333
55334
55335 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55336 PyObject *resultobj = 0;
55337 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55338 wxSize *arg2 = 0 ;
55339 void *argp1 = 0 ;
55340 int res1 = 0 ;
55341 wxSize temp2 ;
55342 PyObject * obj0 = 0 ;
55343 PyObject * obj1 = 0 ;
55344 char * kwnames[] = {
55345 (char *) "self",(char *) "sz", NULL
55346 };
55347
55348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
55349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55350 if (!SWIG_IsOK(res1)) {
55351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55352 }
55353 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55354 {
55355 arg2 = &temp2;
55356 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
55357 }
55358 {
55359 PyThreadState* __tstate = wxPyBeginAllowThreads();
55360 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
55361 wxPyEndAllowThreads(__tstate);
55362 if (PyErr_Occurred()) SWIG_fail;
55363 }
55364 resultobj = SWIG_Py_Void();
55365 return resultobj;
55366 fail:
55367 return NULL;
55368 }
55369
55370
55371 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55372 PyObject *resultobj = 0;
55373 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55374 wxWindow *arg2 = (wxWindow *) 0 ;
55375 wxGBPosition result;
55376 void *argp1 = 0 ;
55377 int res1 = 0 ;
55378 void *argp2 = 0 ;
55379 int res2 = 0 ;
55380
55381 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55383 if (!SWIG_IsOK(res1)) {
55384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55385 }
55386 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55387 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55388 if (!SWIG_IsOK(res2)) {
55389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55390 }
55391 arg2 = reinterpret_cast< wxWindow * >(argp2);
55392 {
55393 PyThreadState* __tstate = wxPyBeginAllowThreads();
55394 result = (arg1)->GetItemPosition(arg2);
55395 wxPyEndAllowThreads(__tstate);
55396 if (PyErr_Occurred()) SWIG_fail;
55397 }
55398 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55399 return resultobj;
55400 fail:
55401 return NULL;
55402 }
55403
55404
55405 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55406 PyObject *resultobj = 0;
55407 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55408 wxSizer *arg2 = (wxSizer *) 0 ;
55409 wxGBPosition result;
55410 void *argp1 = 0 ;
55411 int res1 = 0 ;
55412 void *argp2 = 0 ;
55413 int res2 = 0 ;
55414
55415 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55417 if (!SWIG_IsOK(res1)) {
55418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55419 }
55420 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55421 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55422 if (!SWIG_IsOK(res2)) {
55423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55424 }
55425 arg2 = reinterpret_cast< wxSizer * >(argp2);
55426 {
55427 PyThreadState* __tstate = wxPyBeginAllowThreads();
55428 result = (arg1)->GetItemPosition(arg2);
55429 wxPyEndAllowThreads(__tstate);
55430 if (PyErr_Occurred()) SWIG_fail;
55431 }
55432 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55433 return resultobj;
55434 fail:
55435 return NULL;
55436 }
55437
55438
55439 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55440 PyObject *resultobj = 0;
55441 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55442 size_t arg2 ;
55443 wxGBPosition result;
55444 void *argp1 = 0 ;
55445 int res1 = 0 ;
55446 size_t val2 ;
55447 int ecode2 = 0 ;
55448
55449 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55451 if (!SWIG_IsOK(res1)) {
55452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55453 }
55454 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55455 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55456 if (!SWIG_IsOK(ecode2)) {
55457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55458 }
55459 arg2 = static_cast< size_t >(val2);
55460 {
55461 PyThreadState* __tstate = wxPyBeginAllowThreads();
55462 result = (arg1)->GetItemPosition(arg2);
55463 wxPyEndAllowThreads(__tstate);
55464 if (PyErr_Occurred()) SWIG_fail;
55465 }
55466 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55467 return resultobj;
55468 fail:
55469 return NULL;
55470 }
55471
55472
55473 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
55474 int argc;
55475 PyObject *argv[3];
55476
55477 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
55478 --argc;
55479 if (argc == 2) {
55480 int _v = 0;
55481 {
55482 void *vptr = 0;
55483 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55484 _v = SWIG_CheckState(res);
55485 }
55486 if (!_v) goto check_1;
55487 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
55488 }
55489 check_1:
55490
55491 if (argc == 2) {
55492 int _v = 0;
55493 {
55494 void *vptr = 0;
55495 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55496 _v = SWIG_CheckState(res);
55497 }
55498 if (!_v) goto check_2;
55499 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
55500 }
55501 check_2:
55502
55503 if (argc == 2) {
55504 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
55505 }
55506
55507 fail:
55508 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
55509 return NULL;
55510 }
55511
55512
55513 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55514 PyObject *resultobj = 0;
55515 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55516 wxWindow *arg2 = (wxWindow *) 0 ;
55517 wxGBPosition *arg3 = 0 ;
55518 bool result;
55519 void *argp1 = 0 ;
55520 int res1 = 0 ;
55521 void *argp2 = 0 ;
55522 int res2 = 0 ;
55523 wxGBPosition temp3 ;
55524
55525 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55527 if (!SWIG_IsOK(res1)) {
55528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55529 }
55530 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55531 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55532 if (!SWIG_IsOK(res2)) {
55533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55534 }
55535 arg2 = reinterpret_cast< wxWindow * >(argp2);
55536 {
55537 arg3 = &temp3;
55538 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55539 }
55540 {
55541 PyThreadState* __tstate = wxPyBeginAllowThreads();
55542 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55543 wxPyEndAllowThreads(__tstate);
55544 if (PyErr_Occurred()) SWIG_fail;
55545 }
55546 {
55547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55548 }
55549 return resultobj;
55550 fail:
55551 return NULL;
55552 }
55553
55554
55555 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55556 PyObject *resultobj = 0;
55557 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55558 wxSizer *arg2 = (wxSizer *) 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_wxSizer, 0 | 0 );
55574 if (!SWIG_IsOK(res2)) {
55575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55576 }
55577 arg2 = reinterpret_cast< wxSizer * >(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_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55598 PyObject *resultobj = 0;
55599 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55600 size_t arg2 ;
55601 wxGBPosition *arg3 = 0 ;
55602 bool result;
55603 void *argp1 = 0 ;
55604 int res1 = 0 ;
55605 size_t val2 ;
55606 int ecode2 = 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 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55616 if (!SWIG_IsOK(ecode2)) {
55617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55618 }
55619 arg2 = static_cast< size_t >(val2);
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(PyObject *self, PyObject *args) {
55640 int argc;
55641 PyObject *argv[4];
55642
55643 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
55644 --argc;
55645 if (argc == 3) {
55646 int _v = 0;
55647 {
55648 void *vptr = 0;
55649 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55650 _v = SWIG_CheckState(res);
55651 }
55652 if (!_v) goto check_1;
55653 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
55654 }
55655 check_1:
55656
55657 if (argc == 3) {
55658 int _v = 0;
55659 {
55660 void *vptr = 0;
55661 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55662 _v = SWIG_CheckState(res);
55663 }
55664 if (!_v) goto check_2;
55665 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
55666 }
55667 check_2:
55668
55669 if (argc == 3) {
55670 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
55671 }
55672
55673 fail:
55674 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
55675 return NULL;
55676 }
55677
55678
55679 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55680 PyObject *resultobj = 0;
55681 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55682 wxWindow *arg2 = (wxWindow *) 0 ;
55683 wxGBSpan result;
55684 void *argp1 = 0 ;
55685 int res1 = 0 ;
55686 void *argp2 = 0 ;
55687 int res2 = 0 ;
55688
55689 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55691 if (!SWIG_IsOK(res1)) {
55692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55693 }
55694 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55695 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55696 if (!SWIG_IsOK(res2)) {
55697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55698 }
55699 arg2 = reinterpret_cast< wxWindow * >(argp2);
55700 {
55701 PyThreadState* __tstate = wxPyBeginAllowThreads();
55702 result = (arg1)->GetItemSpan(arg2);
55703 wxPyEndAllowThreads(__tstate);
55704 if (PyErr_Occurred()) SWIG_fail;
55705 }
55706 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55707 return resultobj;
55708 fail:
55709 return NULL;
55710 }
55711
55712
55713 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55714 PyObject *resultobj = 0;
55715 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55716 wxSizer *arg2 = (wxSizer *) 0 ;
55717 wxGBSpan result;
55718 void *argp1 = 0 ;
55719 int res1 = 0 ;
55720 void *argp2 = 0 ;
55721 int res2 = 0 ;
55722
55723 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55725 if (!SWIG_IsOK(res1)) {
55726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55727 }
55728 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55729 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55730 if (!SWIG_IsOK(res2)) {
55731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55732 }
55733 arg2 = reinterpret_cast< wxSizer * >(argp2);
55734 {
55735 PyThreadState* __tstate = wxPyBeginAllowThreads();
55736 result = (arg1)->GetItemSpan(arg2);
55737 wxPyEndAllowThreads(__tstate);
55738 if (PyErr_Occurred()) SWIG_fail;
55739 }
55740 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55741 return resultobj;
55742 fail:
55743 return NULL;
55744 }
55745
55746
55747 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55748 PyObject *resultobj = 0;
55749 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55750 size_t arg2 ;
55751 wxGBSpan result;
55752 void *argp1 = 0 ;
55753 int res1 = 0 ;
55754 size_t val2 ;
55755 int ecode2 = 0 ;
55756
55757 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55759 if (!SWIG_IsOK(res1)) {
55760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55761 }
55762 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55763 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55764 if (!SWIG_IsOK(ecode2)) {
55765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55766 }
55767 arg2 = static_cast< size_t >(val2);
55768 {
55769 PyThreadState* __tstate = wxPyBeginAllowThreads();
55770 result = (arg1)->GetItemSpan(arg2);
55771 wxPyEndAllowThreads(__tstate);
55772 if (PyErr_Occurred()) SWIG_fail;
55773 }
55774 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55775 return resultobj;
55776 fail:
55777 return NULL;
55778 }
55779
55780
55781 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
55782 int argc;
55783 PyObject *argv[3];
55784
55785 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
55786 --argc;
55787 if (argc == 2) {
55788 int _v = 0;
55789 {
55790 void *vptr = 0;
55791 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55792 _v = SWIG_CheckState(res);
55793 }
55794 if (!_v) goto check_1;
55795 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
55796 }
55797 check_1:
55798
55799 if (argc == 2) {
55800 int _v = 0;
55801 {
55802 void *vptr = 0;
55803 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55804 _v = SWIG_CheckState(res);
55805 }
55806 if (!_v) goto check_2;
55807 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
55808 }
55809 check_2:
55810
55811 if (argc == 2) {
55812 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
55813 }
55814
55815 fail:
55816 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
55817 return NULL;
55818 }
55819
55820
55821 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55822 PyObject *resultobj = 0;
55823 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55824 wxWindow *arg2 = (wxWindow *) 0 ;
55825 wxGBSpan *arg3 = 0 ;
55826 bool result;
55827 void *argp1 = 0 ;
55828 int res1 = 0 ;
55829 void *argp2 = 0 ;
55830 int res2 = 0 ;
55831 wxGBSpan temp3 ;
55832
55833 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55835 if (!SWIG_IsOK(res1)) {
55836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55837 }
55838 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55839 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55840 if (!SWIG_IsOK(res2)) {
55841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55842 }
55843 arg2 = reinterpret_cast< wxWindow * >(argp2);
55844 {
55845 arg3 = &temp3;
55846 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
55847 }
55848 {
55849 PyThreadState* __tstate = wxPyBeginAllowThreads();
55850 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
55851 wxPyEndAllowThreads(__tstate);
55852 if (PyErr_Occurred()) SWIG_fail;
55853 }
55854 {
55855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55856 }
55857 return resultobj;
55858 fail:
55859 return NULL;
55860 }
55861
55862
55863 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55864 PyObject *resultobj = 0;
55865 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55866 wxSizer *arg2 = (wxSizer *) 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_wxSizer, 0 | 0 );
55882 if (!SWIG_IsOK(res2)) {
55883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55884 }
55885 arg2 = reinterpret_cast< wxSizer * >(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_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55906 PyObject *resultobj = 0;
55907 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55908 size_t arg2 ;
55909 wxGBSpan *arg3 = 0 ;
55910 bool result;
55911 void *argp1 = 0 ;
55912 int res1 = 0 ;
55913 size_t val2 ;
55914 int ecode2 = 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 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55924 if (!SWIG_IsOK(ecode2)) {
55925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55926 }
55927 arg2 = static_cast< size_t >(val2);
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(PyObject *self, PyObject *args) {
55948 int argc;
55949 PyObject *argv[4];
55950
55951 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
55952 --argc;
55953 if (argc == 3) {
55954 int _v = 0;
55955 {
55956 void *vptr = 0;
55957 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55958 _v = SWIG_CheckState(res);
55959 }
55960 if (!_v) goto check_1;
55961 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
55962 }
55963 check_1:
55964
55965 if (argc == 3) {
55966 int _v = 0;
55967 {
55968 void *vptr = 0;
55969 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55970 _v = SWIG_CheckState(res);
55971 }
55972 if (!_v) goto check_2;
55973 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
55974 }
55975 check_2:
55976
55977 if (argc == 3) {
55978 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
55979 }
55980
55981 fail:
55982 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
55983 return NULL;
55984 }
55985
55986
55987 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55988 PyObject *resultobj = 0;
55989 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55990 wxWindow *arg2 = (wxWindow *) 0 ;
55991 wxGBSizerItem *result = 0 ;
55992 void *argp1 = 0 ;
55993 int res1 = 0 ;
55994 void *argp2 = 0 ;
55995 int res2 = 0 ;
55996
55997 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55999 if (!SWIG_IsOK(res1)) {
56000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56001 }
56002 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56003 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56004 if (!SWIG_IsOK(res2)) {
56005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56006 }
56007 arg2 = reinterpret_cast< wxWindow * >(argp2);
56008 {
56009 PyThreadState* __tstate = wxPyBeginAllowThreads();
56010 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56011 wxPyEndAllowThreads(__tstate);
56012 if (PyErr_Occurred()) SWIG_fail;
56013 }
56014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56015 return resultobj;
56016 fail:
56017 return NULL;
56018 }
56019
56020
56021 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56022 PyObject *resultobj = 0;
56023 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56024 wxSizer *arg2 = (wxSizer *) 0 ;
56025 wxGBSizerItem *result = 0 ;
56026 void *argp1 = 0 ;
56027 int res1 = 0 ;
56028 void *argp2 = 0 ;
56029 int res2 = 0 ;
56030
56031 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56033 if (!SWIG_IsOK(res1)) {
56034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56035 }
56036 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56037 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56038 if (!SWIG_IsOK(res2)) {
56039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56040 }
56041 arg2 = reinterpret_cast< wxSizer * >(argp2);
56042 {
56043 PyThreadState* __tstate = wxPyBeginAllowThreads();
56044 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56045 wxPyEndAllowThreads(__tstate);
56046 if (PyErr_Occurred()) SWIG_fail;
56047 }
56048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56049 return resultobj;
56050 fail:
56051 return NULL;
56052 }
56053
56054
56055 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56056 int argc;
56057 PyObject *argv[3];
56058
56059 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56060 --argc;
56061 if (argc == 2) {
56062 int _v = 0;
56063 {
56064 void *vptr = 0;
56065 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56066 _v = SWIG_CheckState(res);
56067 }
56068 if (!_v) goto check_1;
56069 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56070 }
56071 check_1:
56072
56073 if (argc == 2) {
56074 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56075 }
56076
56077 fail:
56078 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56079 return NULL;
56080 }
56081
56082
56083 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56084 PyObject *resultobj = 0;
56085 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56086 wxGBPosition *arg2 = 0 ;
56087 wxGBSizerItem *result = 0 ;
56088 void *argp1 = 0 ;
56089 int res1 = 0 ;
56090 wxGBPosition temp2 ;
56091 PyObject * obj0 = 0 ;
56092 PyObject * obj1 = 0 ;
56093 char * kwnames[] = {
56094 (char *) "self",(char *) "pos", NULL
56095 };
56096
56097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56099 if (!SWIG_IsOK(res1)) {
56100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56101 }
56102 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56103 {
56104 arg2 = &temp2;
56105 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56106 }
56107 {
56108 PyThreadState* __tstate = wxPyBeginAllowThreads();
56109 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56110 wxPyEndAllowThreads(__tstate);
56111 if (PyErr_Occurred()) SWIG_fail;
56112 }
56113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56114 return resultobj;
56115 fail:
56116 return NULL;
56117 }
56118
56119
56120 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56121 PyObject *resultobj = 0;
56122 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56123 wxPoint *arg2 = 0 ;
56124 wxGBSizerItem *result = 0 ;
56125 void *argp1 = 0 ;
56126 int res1 = 0 ;
56127 wxPoint temp2 ;
56128 PyObject * obj0 = 0 ;
56129 PyObject * obj1 = 0 ;
56130 char * kwnames[] = {
56131 (char *) "self",(char *) "pt", NULL
56132 };
56133
56134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56136 if (!SWIG_IsOK(res1)) {
56137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56138 }
56139 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56140 {
56141 arg2 = &temp2;
56142 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56143 }
56144 {
56145 PyThreadState* __tstate = wxPyBeginAllowThreads();
56146 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56147 wxPyEndAllowThreads(__tstate);
56148 if (PyErr_Occurred()) SWIG_fail;
56149 }
56150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56151 return resultobj;
56152 fail:
56153 return NULL;
56154 }
56155
56156
56157 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56158 PyObject *resultobj = 0;
56159 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56160 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56161 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56162 bool result;
56163 void *argp1 = 0 ;
56164 int res1 = 0 ;
56165 void *argp2 = 0 ;
56166 int res2 = 0 ;
56167 void *argp3 = 0 ;
56168 int res3 = 0 ;
56169 PyObject * obj0 = 0 ;
56170 PyObject * obj1 = 0 ;
56171 PyObject * obj2 = 0 ;
56172 char * kwnames[] = {
56173 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56174 };
56175
56176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) 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_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56180 }
56181 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56183 if (!SWIG_IsOK(res2)) {
56184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56185 }
56186 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56187 if (obj2) {
56188 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56189 if (!SWIG_IsOK(res3)) {
56190 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56191 }
56192 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56193 }
56194 {
56195 PyThreadState* __tstate = wxPyBeginAllowThreads();
56196 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56197 wxPyEndAllowThreads(__tstate);
56198 if (PyErr_Occurred()) SWIG_fail;
56199 }
56200 {
56201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56202 }
56203 return resultobj;
56204 fail:
56205 return NULL;
56206 }
56207
56208
56209 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56210 PyObject *resultobj = 0;
56211 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56212 wxGBPosition *arg2 = 0 ;
56213 wxGBSpan *arg3 = 0 ;
56214 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56215 bool result;
56216 void *argp1 = 0 ;
56217 int res1 = 0 ;
56218 wxGBPosition temp2 ;
56219 wxGBSpan temp3 ;
56220 void *argp4 = 0 ;
56221 int res4 = 0 ;
56222 PyObject * obj0 = 0 ;
56223 PyObject * obj1 = 0 ;
56224 PyObject * obj2 = 0 ;
56225 PyObject * obj3 = 0 ;
56226 char * kwnames[] = {
56227 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56228 };
56229
56230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56232 if (!SWIG_IsOK(res1)) {
56233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56234 }
56235 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56236 {
56237 arg2 = &temp2;
56238 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56239 }
56240 {
56241 arg3 = &temp3;
56242 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56243 }
56244 if (obj3) {
56245 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56246 if (!SWIG_IsOK(res4)) {
56247 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56248 }
56249 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56250 }
56251 {
56252 PyThreadState* __tstate = wxPyBeginAllowThreads();
56253 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56254 wxPyEndAllowThreads(__tstate);
56255 if (PyErr_Occurred()) SWIG_fail;
56256 }
56257 {
56258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56259 }
56260 return resultobj;
56261 fail:
56262 return NULL;
56263 }
56264
56265
56266 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56267 PyObject *obj;
56268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56269 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56270 return SWIG_Py_Void();
56271 }
56272
56273 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56274 return SWIG_Python_InitShadowInstance(args);
56275 }
56276
56277 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56278 PyObject *resultobj = 0;
56279 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56280 wxRelationship arg2 ;
56281 wxWindow *arg3 = (wxWindow *) 0 ;
56282 wxEdge arg4 ;
56283 int arg5 = (int) 0 ;
56284 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56285 void *argp1 = 0 ;
56286 int res1 = 0 ;
56287 int val2 ;
56288 int ecode2 = 0 ;
56289 void *argp3 = 0 ;
56290 int res3 = 0 ;
56291 int val4 ;
56292 int ecode4 = 0 ;
56293 int val5 ;
56294 int ecode5 = 0 ;
56295 int val6 ;
56296 int ecode6 = 0 ;
56297 PyObject * obj0 = 0 ;
56298 PyObject * obj1 = 0 ;
56299 PyObject * obj2 = 0 ;
56300 PyObject * obj3 = 0 ;
56301 PyObject * obj4 = 0 ;
56302 PyObject * obj5 = 0 ;
56303 char * kwnames[] = {
56304 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
56305 };
56306
56307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
56308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56309 if (!SWIG_IsOK(res1)) {
56310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56311 }
56312 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56313 ecode2 = SWIG_AsVal_int(obj1, &val2);
56314 if (!SWIG_IsOK(ecode2)) {
56315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
56316 }
56317 arg2 = static_cast< wxRelationship >(val2);
56318 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56319 if (!SWIG_IsOK(res3)) {
56320 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
56321 }
56322 arg3 = reinterpret_cast< wxWindow * >(argp3);
56323 ecode4 = SWIG_AsVal_int(obj3, &val4);
56324 if (!SWIG_IsOK(ecode4)) {
56325 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
56326 }
56327 arg4 = static_cast< wxEdge >(val4);
56328 if (obj4) {
56329 ecode5 = SWIG_AsVal_int(obj4, &val5);
56330 if (!SWIG_IsOK(ecode5)) {
56331 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
56332 }
56333 arg5 = static_cast< int >(val5);
56334 }
56335 if (obj5) {
56336 ecode6 = SWIG_AsVal_int(obj5, &val6);
56337 if (!SWIG_IsOK(ecode6)) {
56338 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
56339 }
56340 arg6 = static_cast< int >(val6);
56341 }
56342 {
56343 PyThreadState* __tstate = wxPyBeginAllowThreads();
56344 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
56345 wxPyEndAllowThreads(__tstate);
56346 if (PyErr_Occurred()) SWIG_fail;
56347 }
56348 resultobj = SWIG_Py_Void();
56349 return resultobj;
56350 fail:
56351 return NULL;
56352 }
56353
56354
56355 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56356 PyObject *resultobj = 0;
56357 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56358 wxWindow *arg2 = (wxWindow *) 0 ;
56359 int arg3 = (int) 0 ;
56360 void *argp1 = 0 ;
56361 int res1 = 0 ;
56362 void *argp2 = 0 ;
56363 int res2 = 0 ;
56364 int val3 ;
56365 int ecode3 = 0 ;
56366 PyObject * obj0 = 0 ;
56367 PyObject * obj1 = 0 ;
56368 PyObject * obj2 = 0 ;
56369 char * kwnames[] = {
56370 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56371 };
56372
56373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56375 if (!SWIG_IsOK(res1)) {
56376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56377 }
56378 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56380 if (!SWIG_IsOK(res2)) {
56381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56382 }
56383 arg2 = reinterpret_cast< wxWindow * >(argp2);
56384 if (obj2) {
56385 ecode3 = SWIG_AsVal_int(obj2, &val3);
56386 if (!SWIG_IsOK(ecode3)) {
56387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
56388 }
56389 arg3 = static_cast< int >(val3);
56390 }
56391 {
56392 PyThreadState* __tstate = wxPyBeginAllowThreads();
56393 (arg1)->LeftOf(arg2,arg3);
56394 wxPyEndAllowThreads(__tstate);
56395 if (PyErr_Occurred()) SWIG_fail;
56396 }
56397 resultobj = SWIG_Py_Void();
56398 return resultobj;
56399 fail:
56400 return NULL;
56401 }
56402
56403
56404 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56405 PyObject *resultobj = 0;
56406 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56407 wxWindow *arg2 = (wxWindow *) 0 ;
56408 int arg3 = (int) 0 ;
56409 void *argp1 = 0 ;
56410 int res1 = 0 ;
56411 void *argp2 = 0 ;
56412 int res2 = 0 ;
56413 int val3 ;
56414 int ecode3 = 0 ;
56415 PyObject * obj0 = 0 ;
56416 PyObject * obj1 = 0 ;
56417 PyObject * obj2 = 0 ;
56418 char * kwnames[] = {
56419 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56420 };
56421
56422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56424 if (!SWIG_IsOK(res1)) {
56425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56426 }
56427 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56429 if (!SWIG_IsOK(res2)) {
56430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56431 }
56432 arg2 = reinterpret_cast< wxWindow * >(argp2);
56433 if (obj2) {
56434 ecode3 = SWIG_AsVal_int(obj2, &val3);
56435 if (!SWIG_IsOK(ecode3)) {
56436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
56437 }
56438 arg3 = static_cast< int >(val3);
56439 }
56440 {
56441 PyThreadState* __tstate = wxPyBeginAllowThreads();
56442 (arg1)->RightOf(arg2,arg3);
56443 wxPyEndAllowThreads(__tstate);
56444 if (PyErr_Occurred()) SWIG_fail;
56445 }
56446 resultobj = SWIG_Py_Void();
56447 return resultobj;
56448 fail:
56449 return NULL;
56450 }
56451
56452
56453 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56454 PyObject *resultobj = 0;
56455 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56456 wxWindow *arg2 = (wxWindow *) 0 ;
56457 int arg3 = (int) 0 ;
56458 void *argp1 = 0 ;
56459 int res1 = 0 ;
56460 void *argp2 = 0 ;
56461 int res2 = 0 ;
56462 int val3 ;
56463 int ecode3 = 0 ;
56464 PyObject * obj0 = 0 ;
56465 PyObject * obj1 = 0 ;
56466 PyObject * obj2 = 0 ;
56467 char * kwnames[] = {
56468 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56469 };
56470
56471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56473 if (!SWIG_IsOK(res1)) {
56474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56475 }
56476 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56478 if (!SWIG_IsOK(res2)) {
56479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
56480 }
56481 arg2 = reinterpret_cast< wxWindow * >(argp2);
56482 if (obj2) {
56483 ecode3 = SWIG_AsVal_int(obj2, &val3);
56484 if (!SWIG_IsOK(ecode3)) {
56485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
56486 }
56487 arg3 = static_cast< int >(val3);
56488 }
56489 {
56490 PyThreadState* __tstate = wxPyBeginAllowThreads();
56491 (arg1)->Above(arg2,arg3);
56492 wxPyEndAllowThreads(__tstate);
56493 if (PyErr_Occurred()) SWIG_fail;
56494 }
56495 resultobj = SWIG_Py_Void();
56496 return resultobj;
56497 fail:
56498 return NULL;
56499 }
56500
56501
56502 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56503 PyObject *resultobj = 0;
56504 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56505 wxWindow *arg2 = (wxWindow *) 0 ;
56506 int arg3 = (int) 0 ;
56507 void *argp1 = 0 ;
56508 int res1 = 0 ;
56509 void *argp2 = 0 ;
56510 int res2 = 0 ;
56511 int val3 ;
56512 int ecode3 = 0 ;
56513 PyObject * obj0 = 0 ;
56514 PyObject * obj1 = 0 ;
56515 PyObject * obj2 = 0 ;
56516 char * kwnames[] = {
56517 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56518 };
56519
56520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56522 if (!SWIG_IsOK(res1)) {
56523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56524 }
56525 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56527 if (!SWIG_IsOK(res2)) {
56528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
56529 }
56530 arg2 = reinterpret_cast< wxWindow * >(argp2);
56531 if (obj2) {
56532 ecode3 = SWIG_AsVal_int(obj2, &val3);
56533 if (!SWIG_IsOK(ecode3)) {
56534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
56535 }
56536 arg3 = static_cast< int >(val3);
56537 }
56538 {
56539 PyThreadState* __tstate = wxPyBeginAllowThreads();
56540 (arg1)->Below(arg2,arg3);
56541 wxPyEndAllowThreads(__tstate);
56542 if (PyErr_Occurred()) SWIG_fail;
56543 }
56544 resultobj = SWIG_Py_Void();
56545 return resultobj;
56546 fail:
56547 return NULL;
56548 }
56549
56550
56551 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56552 PyObject *resultobj = 0;
56553 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56554 wxWindow *arg2 = (wxWindow *) 0 ;
56555 wxEdge arg3 ;
56556 int arg4 = (int) 0 ;
56557 void *argp1 = 0 ;
56558 int res1 = 0 ;
56559 void *argp2 = 0 ;
56560 int res2 = 0 ;
56561 int val3 ;
56562 int ecode3 = 0 ;
56563 int val4 ;
56564 int ecode4 = 0 ;
56565 PyObject * obj0 = 0 ;
56566 PyObject * obj1 = 0 ;
56567 PyObject * obj2 = 0 ;
56568 PyObject * obj3 = 0 ;
56569 char * kwnames[] = {
56570 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
56571 };
56572
56573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56575 if (!SWIG_IsOK(res1)) {
56576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56577 }
56578 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56580 if (!SWIG_IsOK(res2)) {
56581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
56582 }
56583 arg2 = reinterpret_cast< wxWindow * >(argp2);
56584 ecode3 = SWIG_AsVal_int(obj2, &val3);
56585 if (!SWIG_IsOK(ecode3)) {
56586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
56587 }
56588 arg3 = static_cast< wxEdge >(val3);
56589 if (obj3) {
56590 ecode4 = SWIG_AsVal_int(obj3, &val4);
56591 if (!SWIG_IsOK(ecode4)) {
56592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
56593 }
56594 arg4 = static_cast< int >(val4);
56595 }
56596 {
56597 PyThreadState* __tstate = wxPyBeginAllowThreads();
56598 (arg1)->SameAs(arg2,arg3,arg4);
56599 wxPyEndAllowThreads(__tstate);
56600 if (PyErr_Occurred()) SWIG_fail;
56601 }
56602 resultobj = SWIG_Py_Void();
56603 return resultobj;
56604 fail:
56605 return NULL;
56606 }
56607
56608
56609 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56610 PyObject *resultobj = 0;
56611 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56612 wxWindow *arg2 = (wxWindow *) 0 ;
56613 wxEdge arg3 ;
56614 int arg4 ;
56615 void *argp1 = 0 ;
56616 int res1 = 0 ;
56617 void *argp2 = 0 ;
56618 int res2 = 0 ;
56619 int val3 ;
56620 int ecode3 = 0 ;
56621 int val4 ;
56622 int ecode4 = 0 ;
56623 PyObject * obj0 = 0 ;
56624 PyObject * obj1 = 0 ;
56625 PyObject * obj2 = 0 ;
56626 PyObject * obj3 = 0 ;
56627 char * kwnames[] = {
56628 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
56629 };
56630
56631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56633 if (!SWIG_IsOK(res1)) {
56634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56635 }
56636 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56638 if (!SWIG_IsOK(res2)) {
56639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56640 }
56641 arg2 = reinterpret_cast< wxWindow * >(argp2);
56642 ecode3 = SWIG_AsVal_int(obj2, &val3);
56643 if (!SWIG_IsOK(ecode3)) {
56644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
56645 }
56646 arg3 = static_cast< wxEdge >(val3);
56647 ecode4 = SWIG_AsVal_int(obj3, &val4);
56648 if (!SWIG_IsOK(ecode4)) {
56649 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
56650 }
56651 arg4 = static_cast< int >(val4);
56652 {
56653 PyThreadState* __tstate = wxPyBeginAllowThreads();
56654 (arg1)->PercentOf(arg2,arg3,arg4);
56655 wxPyEndAllowThreads(__tstate);
56656 if (PyErr_Occurred()) SWIG_fail;
56657 }
56658 resultobj = SWIG_Py_Void();
56659 return resultobj;
56660 fail:
56661 return NULL;
56662 }
56663
56664
56665 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56666 PyObject *resultobj = 0;
56667 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56668 int arg2 ;
56669 void *argp1 = 0 ;
56670 int res1 = 0 ;
56671 int val2 ;
56672 int ecode2 = 0 ;
56673 PyObject * obj0 = 0 ;
56674 PyObject * obj1 = 0 ;
56675 char * kwnames[] = {
56676 (char *) "self",(char *) "val", NULL
56677 };
56678
56679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
56680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56681 if (!SWIG_IsOK(res1)) {
56682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56683 }
56684 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56685 ecode2 = SWIG_AsVal_int(obj1, &val2);
56686 if (!SWIG_IsOK(ecode2)) {
56687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
56688 }
56689 arg2 = static_cast< int >(val2);
56690 {
56691 PyThreadState* __tstate = wxPyBeginAllowThreads();
56692 (arg1)->Absolute(arg2);
56693 wxPyEndAllowThreads(__tstate);
56694 if (PyErr_Occurred()) SWIG_fail;
56695 }
56696 resultobj = SWIG_Py_Void();
56697 return resultobj;
56698 fail:
56699 return NULL;
56700 }
56701
56702
56703 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56704 PyObject *resultobj = 0;
56705 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56706 void *argp1 = 0 ;
56707 int res1 = 0 ;
56708 PyObject *swig_obj[1] ;
56709
56710 if (!args) SWIG_fail;
56711 swig_obj[0] = args;
56712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56713 if (!SWIG_IsOK(res1)) {
56714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56715 }
56716 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56717 {
56718 PyThreadState* __tstate = wxPyBeginAllowThreads();
56719 (arg1)->Unconstrained();
56720 wxPyEndAllowThreads(__tstate);
56721 if (PyErr_Occurred()) SWIG_fail;
56722 }
56723 resultobj = SWIG_Py_Void();
56724 return resultobj;
56725 fail:
56726 return NULL;
56727 }
56728
56729
56730 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56731 PyObject *resultobj = 0;
56732 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56733 void *argp1 = 0 ;
56734 int res1 = 0 ;
56735 PyObject *swig_obj[1] ;
56736
56737 if (!args) SWIG_fail;
56738 swig_obj[0] = args;
56739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56740 if (!SWIG_IsOK(res1)) {
56741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56742 }
56743 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56744 {
56745 PyThreadState* __tstate = wxPyBeginAllowThreads();
56746 (arg1)->AsIs();
56747 wxPyEndAllowThreads(__tstate);
56748 if (PyErr_Occurred()) SWIG_fail;
56749 }
56750 resultobj = SWIG_Py_Void();
56751 return resultobj;
56752 fail:
56753 return NULL;
56754 }
56755
56756
56757 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56758 PyObject *resultobj = 0;
56759 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56760 wxWindow *result = 0 ;
56761 void *argp1 = 0 ;
56762 int res1 = 0 ;
56763 PyObject *swig_obj[1] ;
56764
56765 if (!args) SWIG_fail;
56766 swig_obj[0] = args;
56767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56768 if (!SWIG_IsOK(res1)) {
56769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56770 }
56771 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56772 {
56773 PyThreadState* __tstate = wxPyBeginAllowThreads();
56774 result = (wxWindow *)(arg1)->GetOtherWindow();
56775 wxPyEndAllowThreads(__tstate);
56776 if (PyErr_Occurred()) SWIG_fail;
56777 }
56778 {
56779 resultobj = wxPyMake_wxObject(result, 0);
56780 }
56781 return resultobj;
56782 fail:
56783 return NULL;
56784 }
56785
56786
56787 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56788 PyObject *resultobj = 0;
56789 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56790 wxEdge result;
56791 void *argp1 = 0 ;
56792 int res1 = 0 ;
56793 PyObject *swig_obj[1] ;
56794
56795 if (!args) SWIG_fail;
56796 swig_obj[0] = args;
56797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56798 if (!SWIG_IsOK(res1)) {
56799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56800 }
56801 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56802 {
56803 PyThreadState* __tstate = wxPyBeginAllowThreads();
56804 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
56805 wxPyEndAllowThreads(__tstate);
56806 if (PyErr_Occurred()) SWIG_fail;
56807 }
56808 resultobj = SWIG_From_int(static_cast< int >(result));
56809 return resultobj;
56810 fail:
56811 return NULL;
56812 }
56813
56814
56815 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56816 PyObject *resultobj = 0;
56817 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56818 wxEdge arg2 ;
56819 void *argp1 = 0 ;
56820 int res1 = 0 ;
56821 int val2 ;
56822 int ecode2 = 0 ;
56823 PyObject * obj0 = 0 ;
56824 PyObject * obj1 = 0 ;
56825 char * kwnames[] = {
56826 (char *) "self",(char *) "which", NULL
56827 };
56828
56829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
56830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56831 if (!SWIG_IsOK(res1)) {
56832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56833 }
56834 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56835 ecode2 = SWIG_AsVal_int(obj1, &val2);
56836 if (!SWIG_IsOK(ecode2)) {
56837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56838 }
56839 arg2 = static_cast< wxEdge >(val2);
56840 {
56841 PyThreadState* __tstate = wxPyBeginAllowThreads();
56842 (arg1)->SetEdge(arg2);
56843 wxPyEndAllowThreads(__tstate);
56844 if (PyErr_Occurred()) SWIG_fail;
56845 }
56846 resultobj = SWIG_Py_Void();
56847 return resultobj;
56848 fail:
56849 return NULL;
56850 }
56851
56852
56853 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56854 PyObject *resultobj = 0;
56855 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56856 int arg2 ;
56857 void *argp1 = 0 ;
56858 int res1 = 0 ;
56859 int val2 ;
56860 int ecode2 = 0 ;
56861 PyObject * obj0 = 0 ;
56862 PyObject * obj1 = 0 ;
56863 char * kwnames[] = {
56864 (char *) "self",(char *) "v", NULL
56865 };
56866
56867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
56868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56869 if (!SWIG_IsOK(res1)) {
56870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56871 }
56872 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56873 ecode2 = SWIG_AsVal_int(obj1, &val2);
56874 if (!SWIG_IsOK(ecode2)) {
56875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
56876 }
56877 arg2 = static_cast< int >(val2);
56878 {
56879 PyThreadState* __tstate = wxPyBeginAllowThreads();
56880 (arg1)->SetValue(arg2);
56881 wxPyEndAllowThreads(__tstate);
56882 if (PyErr_Occurred()) SWIG_fail;
56883 }
56884 resultobj = SWIG_Py_Void();
56885 return resultobj;
56886 fail:
56887 return NULL;
56888 }
56889
56890
56891 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56892 PyObject *resultobj = 0;
56893 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56894 int result;
56895 void *argp1 = 0 ;
56896 int res1 = 0 ;
56897 PyObject *swig_obj[1] ;
56898
56899 if (!args) SWIG_fail;
56900 swig_obj[0] = args;
56901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56902 if (!SWIG_IsOK(res1)) {
56903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56904 }
56905 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56906 {
56907 PyThreadState* __tstate = wxPyBeginAllowThreads();
56908 result = (int)(arg1)->GetMargin();
56909 wxPyEndAllowThreads(__tstate);
56910 if (PyErr_Occurred()) SWIG_fail;
56911 }
56912 resultobj = SWIG_From_int(static_cast< int >(result));
56913 return resultobj;
56914 fail:
56915 return NULL;
56916 }
56917
56918
56919 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56920 PyObject *resultobj = 0;
56921 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56922 int arg2 ;
56923 void *argp1 = 0 ;
56924 int res1 = 0 ;
56925 int val2 ;
56926 int ecode2 = 0 ;
56927 PyObject * obj0 = 0 ;
56928 PyObject * obj1 = 0 ;
56929 char * kwnames[] = {
56930 (char *) "self",(char *) "m", NULL
56931 };
56932
56933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
56934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56935 if (!SWIG_IsOK(res1)) {
56936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56937 }
56938 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56939 ecode2 = SWIG_AsVal_int(obj1, &val2);
56940 if (!SWIG_IsOK(ecode2)) {
56941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
56942 }
56943 arg2 = static_cast< int >(val2);
56944 {
56945 PyThreadState* __tstate = wxPyBeginAllowThreads();
56946 (arg1)->SetMargin(arg2);
56947 wxPyEndAllowThreads(__tstate);
56948 if (PyErr_Occurred()) SWIG_fail;
56949 }
56950 resultobj = SWIG_Py_Void();
56951 return resultobj;
56952 fail:
56953 return NULL;
56954 }
56955
56956
56957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56958 PyObject *resultobj = 0;
56959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56960 int result;
56961 void *argp1 = 0 ;
56962 int res1 = 0 ;
56963 PyObject *swig_obj[1] ;
56964
56965 if (!args) SWIG_fail;
56966 swig_obj[0] = args;
56967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56968 if (!SWIG_IsOK(res1)) {
56969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56970 }
56971 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56972 {
56973 PyThreadState* __tstate = wxPyBeginAllowThreads();
56974 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
56975 wxPyEndAllowThreads(__tstate);
56976 if (PyErr_Occurred()) SWIG_fail;
56977 }
56978 resultobj = SWIG_From_int(static_cast< int >(result));
56979 return resultobj;
56980 fail:
56981 return NULL;
56982 }
56983
56984
56985 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56986 PyObject *resultobj = 0;
56987 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56988 int result;
56989 void *argp1 = 0 ;
56990 int res1 = 0 ;
56991 PyObject *swig_obj[1] ;
56992
56993 if (!args) SWIG_fail;
56994 swig_obj[0] = args;
56995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56996 if (!SWIG_IsOK(res1)) {
56997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56998 }
56999 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57000 {
57001 PyThreadState* __tstate = wxPyBeginAllowThreads();
57002 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57003 wxPyEndAllowThreads(__tstate);
57004 if (PyErr_Occurred()) SWIG_fail;
57005 }
57006 resultobj = SWIG_From_int(static_cast< int >(result));
57007 return resultobj;
57008 fail:
57009 return NULL;
57010 }
57011
57012
57013 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57014 PyObject *resultobj = 0;
57015 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57016 int result;
57017 void *argp1 = 0 ;
57018 int res1 = 0 ;
57019 PyObject *swig_obj[1] ;
57020
57021 if (!args) SWIG_fail;
57022 swig_obj[0] = args;
57023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57024 if (!SWIG_IsOK(res1)) {
57025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57026 }
57027 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57028 {
57029 PyThreadState* __tstate = wxPyBeginAllowThreads();
57030 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57031 wxPyEndAllowThreads(__tstate);
57032 if (PyErr_Occurred()) SWIG_fail;
57033 }
57034 resultobj = SWIG_From_int(static_cast< int >(result));
57035 return resultobj;
57036 fail:
57037 return NULL;
57038 }
57039
57040
57041 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57042 PyObject *resultobj = 0;
57043 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57044 bool result;
57045 void *argp1 = 0 ;
57046 int res1 = 0 ;
57047 PyObject *swig_obj[1] ;
57048
57049 if (!args) SWIG_fail;
57050 swig_obj[0] = args;
57051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57052 if (!SWIG_IsOK(res1)) {
57053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57054 }
57055 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57056 {
57057 PyThreadState* __tstate = wxPyBeginAllowThreads();
57058 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57059 wxPyEndAllowThreads(__tstate);
57060 if (PyErr_Occurred()) SWIG_fail;
57061 }
57062 {
57063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57064 }
57065 return resultobj;
57066 fail:
57067 return NULL;
57068 }
57069
57070
57071 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57072 PyObject *resultobj = 0;
57073 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57074 bool arg2 ;
57075 void *argp1 = 0 ;
57076 int res1 = 0 ;
57077 bool val2 ;
57078 int ecode2 = 0 ;
57079 PyObject * obj0 = 0 ;
57080 PyObject * obj1 = 0 ;
57081 char * kwnames[] = {
57082 (char *) "self",(char *) "d", NULL
57083 };
57084
57085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57087 if (!SWIG_IsOK(res1)) {
57088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57089 }
57090 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57091 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57092 if (!SWIG_IsOK(ecode2)) {
57093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57094 }
57095 arg2 = static_cast< bool >(val2);
57096 {
57097 PyThreadState* __tstate = wxPyBeginAllowThreads();
57098 (arg1)->SetDone(arg2);
57099 wxPyEndAllowThreads(__tstate);
57100 if (PyErr_Occurred()) SWIG_fail;
57101 }
57102 resultobj = SWIG_Py_Void();
57103 return resultobj;
57104 fail:
57105 return NULL;
57106 }
57107
57108
57109 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57110 PyObject *resultobj = 0;
57111 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57112 wxRelationship result;
57113 void *argp1 = 0 ;
57114 int res1 = 0 ;
57115 PyObject *swig_obj[1] ;
57116
57117 if (!args) SWIG_fail;
57118 swig_obj[0] = args;
57119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57120 if (!SWIG_IsOK(res1)) {
57121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57122 }
57123 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57124 {
57125 PyThreadState* __tstate = wxPyBeginAllowThreads();
57126 result = (wxRelationship)(arg1)->GetRelationship();
57127 wxPyEndAllowThreads(__tstate);
57128 if (PyErr_Occurred()) SWIG_fail;
57129 }
57130 resultobj = SWIG_From_int(static_cast< int >(result));
57131 return resultobj;
57132 fail:
57133 return NULL;
57134 }
57135
57136
57137 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57138 PyObject *resultobj = 0;
57139 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57140 wxRelationship arg2 ;
57141 void *argp1 = 0 ;
57142 int res1 = 0 ;
57143 int val2 ;
57144 int ecode2 = 0 ;
57145 PyObject * obj0 = 0 ;
57146 PyObject * obj1 = 0 ;
57147 char * kwnames[] = {
57148 (char *) "self",(char *) "r", NULL
57149 };
57150
57151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57153 if (!SWIG_IsOK(res1)) {
57154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57155 }
57156 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57157 ecode2 = SWIG_AsVal_int(obj1, &val2);
57158 if (!SWIG_IsOK(ecode2)) {
57159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57160 }
57161 arg2 = static_cast< wxRelationship >(val2);
57162 {
57163 PyThreadState* __tstate = wxPyBeginAllowThreads();
57164 (arg1)->SetRelationship(arg2);
57165 wxPyEndAllowThreads(__tstate);
57166 if (PyErr_Occurred()) SWIG_fail;
57167 }
57168 resultobj = SWIG_Py_Void();
57169 return resultobj;
57170 fail:
57171 return NULL;
57172 }
57173
57174
57175 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57176 PyObject *resultobj = 0;
57177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57178 wxWindow *arg2 = (wxWindow *) 0 ;
57179 bool result;
57180 void *argp1 = 0 ;
57181 int res1 = 0 ;
57182 void *argp2 = 0 ;
57183 int res2 = 0 ;
57184 PyObject * obj0 = 0 ;
57185 PyObject * obj1 = 0 ;
57186 char * kwnames[] = {
57187 (char *) "self",(char *) "otherW", NULL
57188 };
57189
57190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57192 if (!SWIG_IsOK(res1)) {
57193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57194 }
57195 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57197 if (!SWIG_IsOK(res2)) {
57198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57199 }
57200 arg2 = reinterpret_cast< wxWindow * >(argp2);
57201 {
57202 PyThreadState* __tstate = wxPyBeginAllowThreads();
57203 result = (bool)(arg1)->ResetIfWin(arg2);
57204 wxPyEndAllowThreads(__tstate);
57205 if (PyErr_Occurred()) SWIG_fail;
57206 }
57207 {
57208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57209 }
57210 return resultobj;
57211 fail:
57212 return NULL;
57213 }
57214
57215
57216 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57217 PyObject *resultobj = 0;
57218 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57219 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57220 wxWindow *arg3 = (wxWindow *) 0 ;
57221 bool result;
57222 void *argp1 = 0 ;
57223 int res1 = 0 ;
57224 void *argp2 = 0 ;
57225 int res2 = 0 ;
57226 void *argp3 = 0 ;
57227 int res3 = 0 ;
57228 PyObject * obj0 = 0 ;
57229 PyObject * obj1 = 0 ;
57230 PyObject * obj2 = 0 ;
57231 char * kwnames[] = {
57232 (char *) "self",(char *) "constraints",(char *) "win", NULL
57233 };
57234
57235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57237 if (!SWIG_IsOK(res1)) {
57238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57239 }
57240 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57242 if (!SWIG_IsOK(res2)) {
57243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57244 }
57245 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57246 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57247 if (!SWIG_IsOK(res3)) {
57248 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57249 }
57250 arg3 = reinterpret_cast< wxWindow * >(argp3);
57251 {
57252 PyThreadState* __tstate = wxPyBeginAllowThreads();
57253 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57254 wxPyEndAllowThreads(__tstate);
57255 if (PyErr_Occurred()) SWIG_fail;
57256 }
57257 {
57258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57259 }
57260 return resultobj;
57261 fail:
57262 return NULL;
57263 }
57264
57265
57266 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57267 PyObject *resultobj = 0;
57268 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57269 wxEdge arg2 ;
57270 wxWindow *arg3 = (wxWindow *) 0 ;
57271 wxWindow *arg4 = (wxWindow *) 0 ;
57272 int result;
57273 void *argp1 = 0 ;
57274 int res1 = 0 ;
57275 int val2 ;
57276 int ecode2 = 0 ;
57277 void *argp3 = 0 ;
57278 int res3 = 0 ;
57279 void *argp4 = 0 ;
57280 int res4 = 0 ;
57281 PyObject * obj0 = 0 ;
57282 PyObject * obj1 = 0 ;
57283 PyObject * obj2 = 0 ;
57284 PyObject * obj3 = 0 ;
57285 char * kwnames[] = {
57286 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57287 };
57288
57289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57291 if (!SWIG_IsOK(res1)) {
57292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57293 }
57294 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57295 ecode2 = SWIG_AsVal_int(obj1, &val2);
57296 if (!SWIG_IsOK(ecode2)) {
57297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57298 }
57299 arg2 = static_cast< wxEdge >(val2);
57300 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57301 if (!SWIG_IsOK(res3)) {
57302 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
57303 }
57304 arg3 = reinterpret_cast< wxWindow * >(argp3);
57305 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
57306 if (!SWIG_IsOK(res4)) {
57307 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
57308 }
57309 arg4 = reinterpret_cast< wxWindow * >(argp4);
57310 {
57311 PyThreadState* __tstate = wxPyBeginAllowThreads();
57312 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
57313 wxPyEndAllowThreads(__tstate);
57314 if (PyErr_Occurred()) SWIG_fail;
57315 }
57316 resultobj = SWIG_From_int(static_cast< int >(result));
57317 return resultobj;
57318 fail:
57319 return NULL;
57320 }
57321
57322
57323 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57324 PyObject *obj;
57325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57326 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
57327 return SWIG_Py_Void();
57328 }
57329
57330 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57331 PyObject *resultobj = 0;
57332 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57333 wxIndividualLayoutConstraint *result = 0 ;
57334 void *argp1 = 0 ;
57335 int res1 = 0 ;
57336 PyObject *swig_obj[1] ;
57337
57338 if (!args) SWIG_fail;
57339 swig_obj[0] = args;
57340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57341 if (!SWIG_IsOK(res1)) {
57342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57343 }
57344 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57345 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
57346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57347 return resultobj;
57348 fail:
57349 return NULL;
57350 }
57351
57352
57353 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57354 PyObject *resultobj = 0;
57355 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57356 wxIndividualLayoutConstraint *result = 0 ;
57357 void *argp1 = 0 ;
57358 int res1 = 0 ;
57359 PyObject *swig_obj[1] ;
57360
57361 if (!args) SWIG_fail;
57362 swig_obj[0] = args;
57363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57364 if (!SWIG_IsOK(res1)) {
57365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57366 }
57367 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57368 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
57369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57370 return resultobj;
57371 fail:
57372 return NULL;
57373 }
57374
57375
57376 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57377 PyObject *resultobj = 0;
57378 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57379 wxIndividualLayoutConstraint *result = 0 ;
57380 void *argp1 = 0 ;
57381 int res1 = 0 ;
57382 PyObject *swig_obj[1] ;
57383
57384 if (!args) SWIG_fail;
57385 swig_obj[0] = args;
57386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57387 if (!SWIG_IsOK(res1)) {
57388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57389 }
57390 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57391 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
57392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57393 return resultobj;
57394 fail:
57395 return NULL;
57396 }
57397
57398
57399 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57400 PyObject *resultobj = 0;
57401 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57402 wxIndividualLayoutConstraint *result = 0 ;
57403 void *argp1 = 0 ;
57404 int res1 = 0 ;
57405 PyObject *swig_obj[1] ;
57406
57407 if (!args) SWIG_fail;
57408 swig_obj[0] = args;
57409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57410 if (!SWIG_IsOK(res1)) {
57411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57412 }
57413 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57414 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
57415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57416 return resultobj;
57417 fail:
57418 return NULL;
57419 }
57420
57421
57422 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57423 PyObject *resultobj = 0;
57424 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57425 wxIndividualLayoutConstraint *result = 0 ;
57426 void *argp1 = 0 ;
57427 int res1 = 0 ;
57428 PyObject *swig_obj[1] ;
57429
57430 if (!args) SWIG_fail;
57431 swig_obj[0] = args;
57432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57433 if (!SWIG_IsOK(res1)) {
57434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57435 }
57436 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57437 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
57438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57439 return resultobj;
57440 fail:
57441 return NULL;
57442 }
57443
57444
57445 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57446 PyObject *resultobj = 0;
57447 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57448 wxIndividualLayoutConstraint *result = 0 ;
57449 void *argp1 = 0 ;
57450 int res1 = 0 ;
57451 PyObject *swig_obj[1] ;
57452
57453 if (!args) SWIG_fail;
57454 swig_obj[0] = args;
57455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57456 if (!SWIG_IsOK(res1)) {
57457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57458 }
57459 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57460 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
57461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57462 return resultobj;
57463 fail:
57464 return NULL;
57465 }
57466
57467
57468 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57469 PyObject *resultobj = 0;
57470 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57471 wxIndividualLayoutConstraint *result = 0 ;
57472 void *argp1 = 0 ;
57473 int res1 = 0 ;
57474 PyObject *swig_obj[1] ;
57475
57476 if (!args) SWIG_fail;
57477 swig_obj[0] = args;
57478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57479 if (!SWIG_IsOK(res1)) {
57480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57481 }
57482 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57483 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
57484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57485 return resultobj;
57486 fail:
57487 return NULL;
57488 }
57489
57490
57491 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57492 PyObject *resultobj = 0;
57493 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57494 wxIndividualLayoutConstraint *result = 0 ;
57495 void *argp1 = 0 ;
57496 int res1 = 0 ;
57497 PyObject *swig_obj[1] ;
57498
57499 if (!args) SWIG_fail;
57500 swig_obj[0] = args;
57501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57502 if (!SWIG_IsOK(res1)) {
57503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57504 }
57505 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57506 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
57507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57508 return resultobj;
57509 fail:
57510 return NULL;
57511 }
57512
57513
57514 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57515 PyObject *resultobj = 0;
57516 wxLayoutConstraints *result = 0 ;
57517
57518 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
57519 {
57520 PyThreadState* __tstate = wxPyBeginAllowThreads();
57521 result = (wxLayoutConstraints *)new wxLayoutConstraints();
57522 wxPyEndAllowThreads(__tstate);
57523 if (PyErr_Occurred()) SWIG_fail;
57524 }
57525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
57526 return resultobj;
57527 fail:
57528 return NULL;
57529 }
57530
57531
57532 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57533 PyObject *resultobj = 0;
57534 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57535 void *argp1 = 0 ;
57536 int res1 = 0 ;
57537 PyObject *swig_obj[1] ;
57538
57539 if (!args) SWIG_fail;
57540 swig_obj[0] = args;
57541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
57542 if (!SWIG_IsOK(res1)) {
57543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57544 }
57545 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57546 {
57547 PyThreadState* __tstate = wxPyBeginAllowThreads();
57548 delete arg1;
57549
57550 wxPyEndAllowThreads(__tstate);
57551 if (PyErr_Occurred()) SWIG_fail;
57552 }
57553 resultobj = SWIG_Py_Void();
57554 return resultobj;
57555 fail:
57556 return NULL;
57557 }
57558
57559
57560 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57561 PyObject *resultobj = 0;
57562 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57563 wxWindow *arg2 = (wxWindow *) 0 ;
57564 int *arg3 = (int *) 0 ;
57565 bool result;
57566 void *argp1 = 0 ;
57567 int res1 = 0 ;
57568 void *argp2 = 0 ;
57569 int res2 = 0 ;
57570 int temp3 ;
57571 int res3 = SWIG_TMPOBJ ;
57572 PyObject * obj0 = 0 ;
57573 PyObject * obj1 = 0 ;
57574 char * kwnames[] = {
57575 (char *) "self",(char *) "win", NULL
57576 };
57577
57578 arg3 = &temp3;
57579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
57580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57581 if (!SWIG_IsOK(res1)) {
57582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57583 }
57584 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57585 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57586 if (!SWIG_IsOK(res2)) {
57587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
57588 }
57589 arg2 = reinterpret_cast< wxWindow * >(argp2);
57590 {
57591 PyThreadState* __tstate = wxPyBeginAllowThreads();
57592 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
57593 wxPyEndAllowThreads(__tstate);
57594 if (PyErr_Occurred()) SWIG_fail;
57595 }
57596 {
57597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57598 }
57599 if (SWIG_IsTmpObj(res3)) {
57600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
57601 } else {
57602 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
57603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
57604 }
57605 return resultobj;
57606 fail:
57607 return NULL;
57608 }
57609
57610
57611 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57612 PyObject *resultobj = 0;
57613 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57614 bool result;
57615 void *argp1 = 0 ;
57616 int res1 = 0 ;
57617 PyObject *swig_obj[1] ;
57618
57619 if (!args) SWIG_fail;
57620 swig_obj[0] = args;
57621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57622 if (!SWIG_IsOK(res1)) {
57623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
57624 }
57625 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57626 {
57627 PyThreadState* __tstate = wxPyBeginAllowThreads();
57628 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
57629 wxPyEndAllowThreads(__tstate);
57630 if (PyErr_Occurred()) SWIG_fail;
57631 }
57632 {
57633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57634 }
57635 return resultobj;
57636 fail:
57637 return NULL;
57638 }
57639
57640
57641 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57642 PyObject *obj;
57643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57644 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
57645 return SWIG_Py_Void();
57646 }
57647
57648 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57649 return SWIG_Python_InitShadowInstance(args);
57650 }
57651
57652 static PyMethodDef SwigMethods[] = {
57653 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
57654 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
57655 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
57656 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
57658 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
57659 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
57660 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
57661 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
57662 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
57664 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57666 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
57669 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
57670 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57675 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
57677 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
57678 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
57679 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
57681 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
57682 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
57683 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
57684 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
57685 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
57686 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
57687 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
57689 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
57695 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
57696 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
57697 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
57698 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
57699 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
57700 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
57701 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
57703 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
57711 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
57712 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
57713 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
57718 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
57719 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
57721 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
57723 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
57725 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
57727 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
57729 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
57731 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
57732 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
57734 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
57735 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
57736 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
57738 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
57740 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
57741 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
57742 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
57743 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
57763 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
57764 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
57765 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
57766 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
57767 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
57768 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
57769 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
57770 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
57772 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
57773 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
57774 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
57779 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
57780 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
57781 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
57782 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
57783 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
57790 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
57797 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
57798 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
57799 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
57800 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
57802 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
57803 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
57804 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
57806 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
57807 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
57808 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
57809 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
57812 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
57815 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
57818 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
57821 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
57824 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
57827 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
57830 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
57833 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
57839 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
57841 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
57850 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
57853 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
57854 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
57855 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
57856 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
57857 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
57858 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
57859 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
57860 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
57862 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
57863 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
57864 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
57866 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
57867 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
57868 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
57869 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
57874 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
57875 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
57876 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
57877 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
57878 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
57879 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
57882 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
57883 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
57884 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
57886 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
57887 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
57889 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
57890 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
57891 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
57892 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
57893 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
57894 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
57895 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
57896 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
57897 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
57898 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
57899 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
57900 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
57905 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
57911 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
57912 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
57913 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
57914 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
57916 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
57919 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
57922 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
57925 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
57926 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
57927 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
57930 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
57931 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
57932 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57933 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57934 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
57936 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
57937 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
57938 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
57941 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
57942 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
57947 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
57948 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
57949 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
57950 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
57951 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
57952 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
57953 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
57960 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
57961 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
57963 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
57964 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
57965 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
57968 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
57969 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
57970 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
57971 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
57972 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
57974 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
57975 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
57976 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
57977 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
57978 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
57979 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
57980 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
57981 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
57983 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
57984 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
57985 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
57986 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
57987 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
57988 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
57989 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
57990 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
57992 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
57993 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
57994 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
57995 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
57996 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57997 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
57998 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
57999 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58000 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58001 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58002 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58003 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58004 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58005 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58006 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58007 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58008 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58013 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58014 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58015 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58016 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58017 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58018 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58019 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58020 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58021 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58022 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58023 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58024 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58025 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58026 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58027 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58028 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58029 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58030 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58031 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58032 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58033 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58034 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58035 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58036 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58037 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58038 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58039 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58040 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58042 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58043 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58044 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58045 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58046 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58047 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58048 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58049 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58050 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58051 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58052 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58053 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58054 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58055 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58056 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58057 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58058 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58059 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58060 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58061 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58062 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58063 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58064 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58065 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58066 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58071 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58072 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58073 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58074 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58075 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58076 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58077 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58078 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58079 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58080 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58081 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58082 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58083 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58084 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58085 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58086 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58087 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58088 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58089 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58090 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58091 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58092 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58093 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58094 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58095 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58096 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58097 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58098 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58099 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58100 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58101 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58102 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58103 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58104 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58105 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58106 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58107 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58108 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58109 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58110 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58111 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58112 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58113 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58114 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58115 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58116 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58117 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58118 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58119 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58120 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58121 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58122 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58123 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58124 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58125 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58126 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58127 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58128 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58129 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58130 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58131 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58132 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58133 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58134 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58135 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58136 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58137 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58138 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58139 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58140 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58141 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58142 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58143 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58144 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58145 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58146 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58147 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58148 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58149 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58150 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58151 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58152 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58153 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58154 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58155 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58156 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58157 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58158 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58159 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58160 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58161 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58162 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58163 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58164 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58165 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58166 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58167 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58168 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58169 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58170 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58171 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58172 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58173 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58174 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58175 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58176 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58177 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58178 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58179 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58180 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58181 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58182 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58183 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58184 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58185 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58186 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58187 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58188 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58189 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58190 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58191 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58192 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58193 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58194 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58195 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58196 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58197 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58198 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58199 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58200 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58201 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58202 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58203 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58204 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58205 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58206 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58207 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58208 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58209 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58210 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58211 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58212 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58213 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58214 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58215 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58216 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58217 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58218 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58219 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58220 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58221 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58222 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58223 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58224 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58225 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58226 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58227 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58228 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58229 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58230 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58231 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58232 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58233 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58234 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58235 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58236 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58237 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58238 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58239 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58240 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58241 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58242 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58243 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58244 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58245 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58246 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58247 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58248 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58249 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58250 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58251 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58252 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58253 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58254 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58255 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58256 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58257 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58258 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58259 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58260 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58261 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58262 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58263 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58264 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58265 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58266 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58267 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58268 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58269 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58270 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58271 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58272 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58273 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58274 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58275 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58276 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58277 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58278 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58279 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58280 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58281 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58282 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58283 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58284 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58285 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58286 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58287 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
58288 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
58289 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
58290 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
58291 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
58292 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
58293 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
58294 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
58295 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
58296 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
58297 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
58298 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
58299 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
58300 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
58301 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
58302 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
58303 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
58304 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
58305 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
58306 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
58307 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
58308 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58309 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
58310 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
58311 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58312 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58313 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
58314 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
58315 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
58316 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
58317 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
58318 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
58319 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58320 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
58321 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
58322 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58323 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58324 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
58325 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
58326 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58327 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
58328 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
58329 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58330 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
58331 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
58332 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58333 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
58334 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
58335 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
58336 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58337 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
58338 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58339 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
58340 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
58341 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58342 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
58343 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
58344 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
58345 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58346 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
58347 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
58348 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
58349 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58350 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
58351 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
58352 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58353 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
58354 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
58355 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
58356 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
58357 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
58358 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58359 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
58360 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
58361 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
58362 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
58363 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
58364 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
58365 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
58366 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
58367 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58368 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
58369 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
58370 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
58371 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
58372 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58373 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
58374 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
58375 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
58376 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58377 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
58378 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
58379 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
58380 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
58381 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
58382 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
58383 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58384 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
58385 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
58386 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
58387 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
58388 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
58389 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
58390 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
58391 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
58392 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58393 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58394 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58395 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58396 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
58397 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
58398 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
58399 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
58400 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58401 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
58402 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
58403 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
58404 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
58405 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
58406 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
58407 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58408 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
58409 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
58410 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
58411 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58412 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
58413 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
58414 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
58415 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
58416 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
58417 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58418 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58419 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
58420 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
58421 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
58422 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58423 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
58424 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
58425 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
58426 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
58427 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
58428 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
58429 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58430 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
58431 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
58432 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
58433 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
58434 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
58435 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
58436 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
58437 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
58438 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
58439 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58440 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
58441 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
58442 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
58443 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58444 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
58445 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
58446 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
58447 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58448 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
58449 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58450 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
58451 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
58452 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
58453 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
58454 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
58455 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58456 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
58457 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
58458 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
58459 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
58460 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58461 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
58462 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
58463 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58464 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
58465 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58466 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
58467 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
58468 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
58469 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58470 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
58471 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58472 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
58473 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
58474 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
58475 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58476 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
58477 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
58478 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
58479 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
58480 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
58481 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
58482 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
58483 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
58484 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
58485 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
58486 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
58487 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58488 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
58489 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
58490 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
58491 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
58492 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
58493 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
58494 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
58495 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
58496 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
58497 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
58498 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
58499 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
58500 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
58501 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
58502 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
58503 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
58504 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
58505 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
58506 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
58507 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
58508 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58509 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
58510 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
58511 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
58512 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
58513 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
58514 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
58515 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
58516 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
58517 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
58518 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
58519 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
58520 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
58521 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
58522 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
58523 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58525 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58526 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58527 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
58528 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
58529 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
58530 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
58531 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
58532 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
58533 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
58534 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
58535 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
58536 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
58537 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
58538 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58539 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
58540 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
58541 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
58542 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
58543 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
58544 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
58545 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
58546 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
58547 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
58548 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
58549 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
58550 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
58551 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
58552 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
58553 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
58554 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
58555 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
58556 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
58557 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
58558 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
58559 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
58560 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58561 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58562 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
58563 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
58564 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
58565 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
58566 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
58567 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
58568 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
58569 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
58570 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58571 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
58572 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
58573 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
58574 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
58575 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
58576 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
58577 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
58578 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
58579 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
58580 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
58581 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
58582 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
58583 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
58584 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
58585 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
58586 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
58587 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58588 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
58589 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
58590 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
58591 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
58592 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58593 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
58594 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58595 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
58596 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
58597 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
58598 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58599 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
58600 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
58601 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58602 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58603 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
58604 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58605 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58606 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58607 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
58608 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58609 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58610 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
58611 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
58612 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
58613 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
58614 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
58615 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
58618 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
58619 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
58620 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
58621 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
58622 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
58623 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
58624 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
58625 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
58626 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
58627 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
58628 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
58629 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
58630 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
58631 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
58632 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
58633 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
58634 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
58635 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
58636 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
58637 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
58638 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
58639 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58640 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58642 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58643 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
58644 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
58645 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
58646 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
58647 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
58648 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
58649 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
58650 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
58651 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58652 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58653 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
58654 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
58655 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
58656 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
58657 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58658 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
58659 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58660 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
58661 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
58662 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
58663 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
58664 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
58665 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58666 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
58667 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58668 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
58669 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58670 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58671 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
58672 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
58673 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58674 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
58675 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
58676 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
58677 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
58678 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
58679 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
58680 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
58681 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
58682 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
58683 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58684 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58685 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
58686 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
58687 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
58688 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
58689 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
58690 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
58691 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
58692 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
58693 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
58694 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58695 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58696 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
58697 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58698 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58699 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58700 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58701 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
58702 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
58703 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
58704 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
58705 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
58706 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
58707 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58708 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
58709 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58712 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58713 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
58714 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58716 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58717 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
58718 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
58719 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
58720 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
58721 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
58722 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
58724 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
58725 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
58726 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
58727 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
58728 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
58729 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
58730 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
58731 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
58732 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
58733 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58735 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
58737 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
58743 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
58744 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
58745 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
58746 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58747 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
58748 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
58749 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
58751 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
58754 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
58755 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
58756 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
58757 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
58758 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58759 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58760 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
58761 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
58762 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
58763 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
58764 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
58765 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
58766 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
58767 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
58768 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
58769 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58770 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
58771 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
58772 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
58773 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
58774 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58775 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58776 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
58779 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
58780 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
58783 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
58784 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
58785 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
58786 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
58787 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
58788 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
58789 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
58791 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
58792 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
58793 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
58794 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
58795 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
58796 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
58797 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58798 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
58799 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
58800 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
58801 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
58802 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
58805 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
58807 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
58808 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
58809 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
58810 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
58812 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
58813 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58814 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58815 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
58817 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
58818 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
58819 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
58820 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
58821 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
58822 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
58823 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
58824 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58825 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
58826 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
58827 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
58828 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
58829 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
58830 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
58832 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
58833 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
58834 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
58835 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
58836 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58837 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
58842 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
58843 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
58844 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
58845 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
58846 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58847 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58848 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
58850 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
58851 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
58852 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
58853 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58854 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
58855 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
58856 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
58857 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
58859 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
58860 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
58861 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
58862 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
58863 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
58864 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58866 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58867 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58868 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58869 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58871 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58872 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58873 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58874 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
58875 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
58876 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58877 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
58878 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58879 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
58880 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
58881 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
58882 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
58883 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
58884 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
58885 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
58886 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
58887 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
58888 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
58889 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
58890 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
58891 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
58892 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
58893 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
58894 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58895 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58896 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
58897 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
58898 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
58899 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
58900 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
58901 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
58902 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
58903 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58904 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58905 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58906 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58908 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
58913 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
58914 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
58916 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
58917 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58918 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
58919 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
58920 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
58921 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
58922 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
58923 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
58924 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58925 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58926 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
58927 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
58928 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58929 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
58930 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
58931 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
58932 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
58933 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
58935 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
58936 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
58937 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58938 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
58939 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
58941 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58942 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
58943 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
58944 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
58945 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
58946 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
58947 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
58948 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58949 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
58950 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58951 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
58952 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
58953 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
58954 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58955 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
58956 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
58957 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58958 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
58959 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58960 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
58961 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
58962 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
58963 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
58964 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
58965 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
58966 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
58967 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
58968 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
58969 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58970 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
58971 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
58972 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
58973 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
58974 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
58975 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
58976 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
58978 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
58979 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
58980 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58982 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58983 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
58984 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
58985 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
58986 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
58987 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58988 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
58989 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
58990 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
58991 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
58992 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
58993 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
58994 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
58995 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
58996 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
58997 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
58998 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
58999 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59000 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59001 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59002 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59003 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59004 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59005 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59006 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59007 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59008 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59009 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59010 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59011 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59012 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59013 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59014 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59015 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59016 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59017 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59018 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59019 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59020 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59021 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59022 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59023 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59024 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59025 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59026 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59027 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59028 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59029 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59030 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59031 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59032 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59033 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59034 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59035 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59036 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59037 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59038 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59039 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59040 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59041 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59042 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59043 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59044 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59045 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59046 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59047 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59048 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59049 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59050 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59051 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59052 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59053 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59054 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59055 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59056 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59057 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59058 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59059 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59060 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59061 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59062 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59063 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59064 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59065 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59066 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59067 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59068 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59069 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59071 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59072 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59073 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59074 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59075 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59076 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59077 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59078 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59079 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59080 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59081 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59082 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59083 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59084 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59085 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59086 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59087 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59088 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59089 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59090 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59091 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59092 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59093 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59094 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59095 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59097 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59098 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59099 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59100 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59101 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59102 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59103 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59104 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59105 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59107 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59108 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59109 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59110 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59111 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59112 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59113 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59114 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59115 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59116 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59117 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59118 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59119 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59120 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59121 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59122 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59123 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59125 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59126 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59127 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59128 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59129 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59130 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59131 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59132 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59133 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59134 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59135 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59136 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59137 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59138 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59139 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59140 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59141 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59142 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59143 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59144 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59145 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59146 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59147 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59148 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59149 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59150 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59151 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59152 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59153 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59154 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59155 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59156 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59157 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59158 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59159 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59160 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59161 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59162 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59163 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59164 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59165 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59166 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59168 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59169 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59170 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59171 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59172 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59173 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59174 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59175 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59178 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59179 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59180 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59182 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59183 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59184 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59185 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59186 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59187 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59188 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59189 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59190 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59191 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59192 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59193 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59194 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59195 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59196 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59197 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59198 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59199 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59200 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59202 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59203 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59204 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59205 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59206 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59207 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59208 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59209 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59210 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59211 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59212 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59213 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59214 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59215 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59216 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59217 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59218 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59219 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59221 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59222 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59223 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59224 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59225 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59226 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59227 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59228 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59229 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59230 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59231 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59232 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59233 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59234 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59235 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59236 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59237 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59238 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59239 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59240 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59241 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59242 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59243 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59244 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59245 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59246 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59247 { NULL, NULL, 0, NULL }
59248 };
59249
59250
59251 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59252
59253 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59254 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59255 }
59256 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59257 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59258 }
59259 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59260 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59261 }
59262 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59263 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59264 }
59265 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59266 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59267 }
59268 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59269 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59270 }
59271 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59272 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59273 }
59274 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59275 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59276 }
59277 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59278 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59279 }
59280 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59281 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59282 }
59283 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59284 return (void *)((wxEvent *) ((wxPyEvent *) x));
59285 }
59286 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
59287 return (void *)((wxEvent *) ((wxIdleEvent *) x));
59288 }
59289 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
59290 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
59291 }
59292 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
59293 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
59294 }
59295 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
59296 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
59297 }
59298 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
59299 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
59300 }
59301 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
59302 return (void *)((wxEvent *) ((wxActivateEvent *) x));
59303 }
59304 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
59305 return (void *)((wxEvent *) ((wxSizeEvent *) x));
59306 }
59307 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
59308 return (void *)((wxEvent *) ((wxMoveEvent *) x));
59309 }
59310 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
59311 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
59312 }
59313 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
59314 return (void *)((wxEvent *) ((wxPaintEvent *) x));
59315 }
59316 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
59317 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
59318 }
59319 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
59320 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
59321 }
59322 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
59323 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
59324 }
59325 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
59326 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
59327 }
59328 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
59329 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
59330 }
59331 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
59332 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59333 }
59334 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
59335 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
59336 }
59337 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
59338 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
59339 }
59340 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
59341 return (void *)((wxEvent *) ((wxFocusEvent *) x));
59342 }
59343 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
59344 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
59345 }
59346 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
59347 return (void *)((wxEvent *) ((wxShowEvent *) x));
59348 }
59349 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
59350 return (void *)((wxEvent *) ((wxCommandEvent *) x));
59351 }
59352 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
59353 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
59354 }
59355 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
59356 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59357 }
59358 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
59359 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
59360 }
59361 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
59362 return (void *)((wxEvent *) ((wxKeyEvent *) x));
59363 }
59364 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
59365 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
59366 }
59367 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
59368 return (void *)((wxValidator *) ((wxPyValidator *) x));
59369 }
59370 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
59371 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
59372 }
59373 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
59374 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
59375 }
59376 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
59377 return (void *)((wxObject *) ((wxSizerItem *) x));
59378 }
59379 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
59380 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
59381 }
59382 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
59383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
59384 }
59385 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
59386 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
59387 }
59388 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
59389 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
59390 }
59391 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
59392 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
59393 }
59394 static void *_p_wxSizerTo_p_wxObject(void *x) {
59395 return (void *)((wxObject *) ((wxSizer *) x));
59396 }
59397 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
59398 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59399 }
59400 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
59401 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
59402 }
59403 static void *_p_wxEventTo_p_wxObject(void *x) {
59404 return (void *)((wxObject *) ((wxEvent *) x));
59405 }
59406 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
59407 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
59408 }
59409 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
59410 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
59411 }
59412 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
59413 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
59414 }
59415 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
59416 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
59417 }
59418 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
59419 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
59420 }
59421 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
59422 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
59423 }
59424 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
59425 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
59426 }
59427 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
59428 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
59429 }
59430 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
59431 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59432 }
59433 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
59434 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
59435 }
59436 static void *_p_wxControlTo_p_wxObject(void *x) {
59437 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
59438 }
59439 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
59440 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
59441 }
59442 static void *_p_wxFSFileTo_p_wxObject(void *x) {
59443 return (void *)((wxObject *) ((wxFSFile *) x));
59444 }
59445 static void *_p_wxPySizerTo_p_wxObject(void *x) {
59446 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
59447 }
59448 static void *_p_wxPyEventTo_p_wxObject(void *x) {
59449 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
59450 }
59451 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
59452 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
59453 }
59454 static void *_p_wxShowEventTo_p_wxObject(void *x) {
59455 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
59456 }
59457 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
59458 return (void *)((wxObject *) ((wxMenuItem *) x));
59459 }
59460 static void *_p_wxDateEventTo_p_wxObject(void *x) {
59461 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
59462 }
59463 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
59464 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
59465 }
59466 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
59467 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
59468 }
59469 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
59470 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
59471 }
59472 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
59473 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
59474 }
59475 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
59476 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
59477 }
59478 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
59479 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
59480 }
59481 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
59482 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
59483 }
59484 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
59485 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
59486 }
59487 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
59488 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
59489 }
59490 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
59491 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
59492 }
59493 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
59494 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
59495 }
59496 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
59497 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
59498 }
59499 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
59500 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
59501 }
59502 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
59503 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59504 }
59505 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
59506 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59507 }
59508 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
59509 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
59510 }
59511 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
59512 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
59513 }
59514 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
59515 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
59516 }
59517 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
59518 return (void *)((wxObject *) ((wxImageHandler *) x));
59519 }
59520 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
59521 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
59522 }
59523 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
59524 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
59525 }
59526 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
59527 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
59528 }
59529 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
59530 return (void *)((wxObject *) ((wxEvtHandler *) x));
59531 }
59532 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
59533 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
59534 }
59535 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
59536 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
59537 }
59538 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
59539 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59540 }
59541 static void *_p_wxImageTo_p_wxObject(void *x) {
59542 return (void *)((wxObject *) ((wxImage *) x));
59543 }
59544 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
59545 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
59546 }
59547 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
59548 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59549 }
59550 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
59551 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
59552 }
59553 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
59554 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
59555 }
59556 static void *_p_wxWindowTo_p_wxObject(void *x) {
59557 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
59558 }
59559 static void *_p_wxMenuTo_p_wxObject(void *x) {
59560 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
59561 }
59562 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
59563 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
59564 }
59565 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
59566 return (void *)((wxObject *) ((wxFileSystem *) x));
59567 }
59568 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
59569 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
59570 }
59571 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
59572 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
59573 }
59574 static void *_p_wxPyAppTo_p_wxObject(void *x) {
59575 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
59576 }
59577 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
59578 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
59579 }
59580 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
59581 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
59582 }
59583 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
59584 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
59585 }
59586 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
59587 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
59588 }
59589 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
59590 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
59591 }
59592 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
59593 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
59594 }
59595 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
59596 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
59597 }
59598 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
59599 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
59600 }
59601 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
59602 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59603 }
59604 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
59605 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
59606 }
59607 static void *_p_wxValidatorTo_p_wxObject(void *x) {
59608 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
59609 }
59610 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
59611 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
59612 }
59613 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
59614 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
59615 }
59616 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
59617 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
59618 }
59619 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
59620 return (void *)((wxControl *) ((wxControlWithItems *) x));
59621 }
59622 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
59623 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
59624 }
59625 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
59626 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
59627 }
59628 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
59629 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59630 }
59631 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
59632 return (void *)((wxSizer *) ((wxBoxSizer *) x));
59633 }
59634 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
59635 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
59636 }
59637 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
59638 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59639 }
59640 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
59641 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59642 }
59643 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
59644 return (void *)((wxSizer *) ((wxGridSizer *) x));
59645 }
59646 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
59647 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
59648 }
59649 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
59650 return (void *)((wxSizer *) ((wxPySizer *) x));
59651 }
59652 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
59653 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
59654 }
59655 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
59656 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
59657 }
59658 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
59659 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
59660 }
59661 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
59662 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
59663 }
59664 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
59665 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
59666 }
59667 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
59668 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
59669 }
59670 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
59671 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
59672 }
59673 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
59674 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
59675 }
59676 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
59677 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59678 }
59679 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
59680 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59681 }
59682 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
59683 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
59684 }
59685 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
59686 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
59687 }
59688 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
59689 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
59690 }
59691 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
59692 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
59693 }
59694 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
59695 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
59696 }
59697 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
59698 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
59699 }
59700 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
59701 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
59702 }
59703 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
59704 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
59705 }
59706 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
59707 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
59708 }
59709 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
59710 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
59711 }
59712 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
59713 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59714 }
59715 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
59716 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
59717 }
59718 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
59719 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
59720 }
59721 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
59722 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
59723 }
59724 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
59725 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
59726 }
59727 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
59728 return (void *)((wxEvtHandler *) ((wxWindow *) x));
59729 }
59730 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
59731 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59732 }
59733 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
59734 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
59735 }
59736 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
59737 return (void *)((wxEvtHandler *) ((wxValidator *) x));
59738 }
59739 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
59740 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
59741 }
59742 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
59743 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
59744 }
59745 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
59746 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
59747 }
59748 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
59749 return (void *)((wxEvtHandler *) ((wxMenu *) x));
59750 }
59751 static void *_p_wxControlTo_p_wxWindow(void *x) {
59752 return (void *)((wxWindow *) ((wxControl *) x));
59753 }
59754 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
59755 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
59756 }
59757 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
59758 return (void *)((wxWindow *) ((wxMenuBar *) x));
59759 }
59760 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
59761 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
59762 }
59763 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
59764 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
59765 }
59766 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
59767 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
59768 }
59769 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
59770 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
59771 }
59772 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
59773 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
59774 }
59775 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
59776 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
59777 }
59778 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
59779 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59780 }
59781 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
59782 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
59783 }
59784 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
59785 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
59786 }
59787 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
59788 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
59789 }
59790 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
59791 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
59792 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};
59793 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
59794 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
59795 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
59796 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
59797 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
59798 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
59799 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
59800 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
59801 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
59802 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
59803 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
59804 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
59805 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
59806 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
59807 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
59808 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
59809 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
59810 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
59811 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
59812 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
59813 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
59814 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
59815 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
59816 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
59817 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
59818 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
59819 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
59820 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
59821 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
59822 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
59823 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
59824 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
59825 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
59826 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
59827 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
59828 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
59829 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
59830 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
59831 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
59832 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
59833 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
59834 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
59835 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
59836 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
59837 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
59838 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
59839 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
59840 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
59841 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
59842 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
59843 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
59844 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
59845 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
59846 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
59847 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
59848 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
59849 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
59850 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
59851 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
59852 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
59853 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
59854 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
59855 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
59856 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
59857 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
59858 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
59859 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
59860 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
59861 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
59862 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
59863 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
59864 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
59865 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
59866 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
59867 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
59868 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
59869 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
59870 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
59871 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
59872 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
59873 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
59874 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
59875 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
59876 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
59877 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
59878 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
59879 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
59880 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
59881 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
59882 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
59883 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
59884 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
59885 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
59886 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
59887 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
59888 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
59889 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
59890 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
59891 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
59892 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
59893 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
59894 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
59895 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
59896 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
59897 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
59898 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
59899 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
59900 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
59901 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
59902 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
59903 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
59904 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
59905 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
59906 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
59907 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
59908 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
59909 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
59910 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
59911 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
59912 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
59913 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
59914 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
59915 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
59916 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
59917 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
59918 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
59919 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
59920 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
59921 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
59922 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
59923 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
59924 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
59925 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
59926 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
59927
59928 static swig_type_info *swig_type_initial[] = {
59929 &_swigt__p_buffer,
59930 &_swigt__p_char,
59931 &_swigt__p_form_ops_t,
59932 &_swigt__p_int,
59933 &_swigt__p_long,
59934 &_swigt__p_unsigned_char,
59935 &_swigt__p_unsigned_int,
59936 &_swigt__p_unsigned_long,
59937 &_swigt__p_wxANIHandler,
59938 &_swigt__p_wxAcceleratorEntry,
59939 &_swigt__p_wxAcceleratorTable,
59940 &_swigt__p_wxActivateEvent,
59941 &_swigt__p_wxAppTraits,
59942 &_swigt__p_wxArrayString,
59943 &_swigt__p_wxBMPHandler,
59944 &_swigt__p_wxBitmap,
59945 &_swigt__p_wxBoxSizer,
59946 &_swigt__p_wxButton,
59947 &_swigt__p_wxCURHandler,
59948 &_swigt__p_wxCaret,
59949 &_swigt__p_wxChildFocusEvent,
59950 &_swigt__p_wxClipboardTextEvent,
59951 &_swigt__p_wxCloseEvent,
59952 &_swigt__p_wxColour,
59953 &_swigt__p_wxCommandEvent,
59954 &_swigt__p_wxContextMenuEvent,
59955 &_swigt__p_wxControl,
59956 &_swigt__p_wxControlWithItems,
59957 &_swigt__p_wxCursor,
59958 &_swigt__p_wxDC,
59959 &_swigt__p_wxDateEvent,
59960 &_swigt__p_wxDateTime,
59961 &_swigt__p_wxDisplayChangedEvent,
59962 &_swigt__p_wxDouble,
59963 &_swigt__p_wxDropFilesEvent,
59964 &_swigt__p_wxDuplexMode,
59965 &_swigt__p_wxEraseEvent,
59966 &_swigt__p_wxEvent,
59967 &_swigt__p_wxEventBlocker,
59968 &_swigt__p_wxEventLoop,
59969 &_swigt__p_wxEventLoopActivator,
59970 &_swigt__p_wxEvtHandler,
59971 &_swigt__p_wxFSFile,
59972 &_swigt__p_wxFileSystem,
59973 &_swigt__p_wxFileSystemHandler,
59974 &_swigt__p_wxFlexGridSizer,
59975 &_swigt__p_wxFocusEvent,
59976 &_swigt__p_wxFont,
59977 &_swigt__p_wxFrame,
59978 &_swigt__p_wxGBPosition,
59979 &_swigt__p_wxGBSizerItem,
59980 &_swigt__p_wxGBSpan,
59981 &_swigt__p_wxGIFHandler,
59982 &_swigt__p_wxGridBagSizer,
59983 &_swigt__p_wxGridSizer,
59984 &_swigt__p_wxHelpEvent__Origin,
59985 &_swigt__p_wxICOHandler,
59986 &_swigt__p_wxIconizeEvent,
59987 &_swigt__p_wxIdleEvent,
59988 &_swigt__p_wxImage,
59989 &_swigt__p_wxImageHandler,
59990 &_swigt__p_wxImageHistogram,
59991 &_swigt__p_wxImage_HSVValue,
59992 &_swigt__p_wxImage_RGBValue,
59993 &_swigt__p_wxIndividualLayoutConstraint,
59994 &_swigt__p_wxInitDialogEvent,
59995 &_swigt__p_wxInputStream,
59996 &_swigt__p_wxInternetFSHandler,
59997 &_swigt__p_wxItemContainer,
59998 &_swigt__p_wxJPEGHandler,
59999 &_swigt__p_wxKeyEvent,
60000 &_swigt__p_wxLayoutConstraints,
60001 &_swigt__p_wxMaximizeEvent,
60002 &_swigt__p_wxMemoryFSHandler,
60003 &_swigt__p_wxMenu,
60004 &_swigt__p_wxMenuBar,
60005 &_swigt__p_wxMenuBarBase,
60006 &_swigt__p_wxMenuEvent,
60007 &_swigt__p_wxMenuItem,
60008 &_swigt__p_wxMouseCaptureChangedEvent,
60009 &_swigt__p_wxMouseCaptureLostEvent,
60010 &_swigt__p_wxMouseEvent,
60011 &_swigt__p_wxMoveEvent,
60012 &_swigt__p_wxNavigationKeyEvent,
60013 &_swigt__p_wxNcPaintEvent,
60014 &_swigt__p_wxNotifyEvent,
60015 &_swigt__p_wxObject,
60016 &_swigt__p_wxOutputStream,
60017 &_swigt__p_wxPCXHandler,
60018 &_swigt__p_wxPNGHandler,
60019 &_swigt__p_wxPNMHandler,
60020 &_swigt__p_wxPaintEvent,
60021 &_swigt__p_wxPaletteChangedEvent,
60022 &_swigt__p_wxPaperSize,
60023 &_swigt__p_wxPoint,
60024 &_swigt__p_wxPoint2D,
60025 &_swigt__p_wxPropagateOnce,
60026 &_swigt__p_wxPropagationDisabler,
60027 &_swigt__p_wxPyApp,
60028 &_swigt__p_wxPyCommandEvent,
60029 &_swigt__p_wxPyDropTarget,
60030 &_swigt__p_wxPyEvent,
60031 &_swigt__p_wxPyFileSystemHandler,
60032 &_swigt__p_wxPyImageHandler,
60033 &_swigt__p_wxPyInputStream,
60034 &_swigt__p_wxPySizer,
60035 &_swigt__p_wxPyValidator,
60036 &_swigt__p_wxQuantize,
60037 &_swigt__p_wxQueryNewPaletteEvent,
60038 &_swigt__p_wxRealPoint,
60039 &_swigt__p_wxRect,
60040 &_swigt__p_wxRect2D,
60041 &_swigt__p_wxRegion,
60042 &_swigt__p_wxScrollEvent,
60043 &_swigt__p_wxScrollWinEvent,
60044 &_swigt__p_wxSetCursorEvent,
60045 &_swigt__p_wxShowEvent,
60046 &_swigt__p_wxSize,
60047 &_swigt__p_wxSizeEvent,
60048 &_swigt__p_wxSizer,
60049 &_swigt__p_wxSizerFlags,
60050 &_swigt__p_wxSizerItem,
60051 &_swigt__p_wxStaticBox,
60052 &_swigt__p_wxStaticBoxSizer,
60053 &_swigt__p_wxStdDialogButtonSizer,
60054 &_swigt__p_wxSysColourChangedEvent,
60055 &_swigt__p_wxTGAHandler,
60056 &_swigt__p_wxTIFFHandler,
60057 &_swigt__p_wxToolTip,
60058 &_swigt__p_wxUpdateUIEvent,
60059 &_swigt__p_wxValidator,
60060 &_swigt__p_wxVisualAttributes,
60061 &_swigt__p_wxWindow,
60062 &_swigt__p_wxWindowCreateEvent,
60063 &_swigt__p_wxWindowDestroyEvent,
60064 &_swigt__p_wxXPMHandler,
60065 &_swigt__p_wxZipFSHandler,
60066 };
60067
60068 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60069 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60070 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60071 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60072 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60073 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60074 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60075 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60076 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60077 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60078 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60079 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60080 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60081 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60082 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}};
60083 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60084 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}};
60085 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60086 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}};
60087 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60088 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60089 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60090 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60091 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60092 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}};
60093 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60094 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}};
60095 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60096 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60097 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60098 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60099 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60100 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60101 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60102 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60103 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60104 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60105 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}};
60106 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60107 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60108 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60109 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}};
60110 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60111 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60112 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}};
60113 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}};
60114 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60115 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60116 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60117 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60118 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60119 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60120 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60121 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60122 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}};
60123 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60124 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}};
60125 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60126 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60127 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60128 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}};
60129 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60130 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60131 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60132 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60133 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60134 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60135 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60136 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}};
60137 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60138 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60139 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60140 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60141 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60142 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60143 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60144 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60145 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60146 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60147 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60148 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60149 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60150 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60151 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60152 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60153 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60154 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}};
60155 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60156 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60157 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60158 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60159 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60160 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60161 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60162 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60163 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60164 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60165 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60166 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60167 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60168 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60169 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60170 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60171 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60172 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60173 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60174 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60175 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60176 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60177 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60178 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60179 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60180 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60181 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60182 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60183 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60184 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60185 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60186 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60187 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}};
60188 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60189 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}};
60190 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60191 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60192 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60193 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60194 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60195 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60196 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60197 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60198 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}};
60199 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60200 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}};
60201 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60202 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60203 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60204 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60205
60206 static swig_cast_info *swig_cast_initial[] = {
60207 _swigc__p_buffer,
60208 _swigc__p_char,
60209 _swigc__p_form_ops_t,
60210 _swigc__p_int,
60211 _swigc__p_long,
60212 _swigc__p_unsigned_char,
60213 _swigc__p_unsigned_int,
60214 _swigc__p_unsigned_long,
60215 _swigc__p_wxANIHandler,
60216 _swigc__p_wxAcceleratorEntry,
60217 _swigc__p_wxAcceleratorTable,
60218 _swigc__p_wxActivateEvent,
60219 _swigc__p_wxAppTraits,
60220 _swigc__p_wxArrayString,
60221 _swigc__p_wxBMPHandler,
60222 _swigc__p_wxBitmap,
60223 _swigc__p_wxBoxSizer,
60224 _swigc__p_wxButton,
60225 _swigc__p_wxCURHandler,
60226 _swigc__p_wxCaret,
60227 _swigc__p_wxChildFocusEvent,
60228 _swigc__p_wxClipboardTextEvent,
60229 _swigc__p_wxCloseEvent,
60230 _swigc__p_wxColour,
60231 _swigc__p_wxCommandEvent,
60232 _swigc__p_wxContextMenuEvent,
60233 _swigc__p_wxControl,
60234 _swigc__p_wxControlWithItems,
60235 _swigc__p_wxCursor,
60236 _swigc__p_wxDC,
60237 _swigc__p_wxDateEvent,
60238 _swigc__p_wxDateTime,
60239 _swigc__p_wxDisplayChangedEvent,
60240 _swigc__p_wxDouble,
60241 _swigc__p_wxDropFilesEvent,
60242 _swigc__p_wxDuplexMode,
60243 _swigc__p_wxEraseEvent,
60244 _swigc__p_wxEvent,
60245 _swigc__p_wxEventBlocker,
60246 _swigc__p_wxEventLoop,
60247 _swigc__p_wxEventLoopActivator,
60248 _swigc__p_wxEvtHandler,
60249 _swigc__p_wxFSFile,
60250 _swigc__p_wxFileSystem,
60251 _swigc__p_wxFileSystemHandler,
60252 _swigc__p_wxFlexGridSizer,
60253 _swigc__p_wxFocusEvent,
60254 _swigc__p_wxFont,
60255 _swigc__p_wxFrame,
60256 _swigc__p_wxGBPosition,
60257 _swigc__p_wxGBSizerItem,
60258 _swigc__p_wxGBSpan,
60259 _swigc__p_wxGIFHandler,
60260 _swigc__p_wxGridBagSizer,
60261 _swigc__p_wxGridSizer,
60262 _swigc__p_wxHelpEvent__Origin,
60263 _swigc__p_wxICOHandler,
60264 _swigc__p_wxIconizeEvent,
60265 _swigc__p_wxIdleEvent,
60266 _swigc__p_wxImage,
60267 _swigc__p_wxImageHandler,
60268 _swigc__p_wxImageHistogram,
60269 _swigc__p_wxImage_HSVValue,
60270 _swigc__p_wxImage_RGBValue,
60271 _swigc__p_wxIndividualLayoutConstraint,
60272 _swigc__p_wxInitDialogEvent,
60273 _swigc__p_wxInputStream,
60274 _swigc__p_wxInternetFSHandler,
60275 _swigc__p_wxItemContainer,
60276 _swigc__p_wxJPEGHandler,
60277 _swigc__p_wxKeyEvent,
60278 _swigc__p_wxLayoutConstraints,
60279 _swigc__p_wxMaximizeEvent,
60280 _swigc__p_wxMemoryFSHandler,
60281 _swigc__p_wxMenu,
60282 _swigc__p_wxMenuBar,
60283 _swigc__p_wxMenuBarBase,
60284 _swigc__p_wxMenuEvent,
60285 _swigc__p_wxMenuItem,
60286 _swigc__p_wxMouseCaptureChangedEvent,
60287 _swigc__p_wxMouseCaptureLostEvent,
60288 _swigc__p_wxMouseEvent,
60289 _swigc__p_wxMoveEvent,
60290 _swigc__p_wxNavigationKeyEvent,
60291 _swigc__p_wxNcPaintEvent,
60292 _swigc__p_wxNotifyEvent,
60293 _swigc__p_wxObject,
60294 _swigc__p_wxOutputStream,
60295 _swigc__p_wxPCXHandler,
60296 _swigc__p_wxPNGHandler,
60297 _swigc__p_wxPNMHandler,
60298 _swigc__p_wxPaintEvent,
60299 _swigc__p_wxPaletteChangedEvent,
60300 _swigc__p_wxPaperSize,
60301 _swigc__p_wxPoint,
60302 _swigc__p_wxPoint2D,
60303 _swigc__p_wxPropagateOnce,
60304 _swigc__p_wxPropagationDisabler,
60305 _swigc__p_wxPyApp,
60306 _swigc__p_wxPyCommandEvent,
60307 _swigc__p_wxPyDropTarget,
60308 _swigc__p_wxPyEvent,
60309 _swigc__p_wxPyFileSystemHandler,
60310 _swigc__p_wxPyImageHandler,
60311 _swigc__p_wxPyInputStream,
60312 _swigc__p_wxPySizer,
60313 _swigc__p_wxPyValidator,
60314 _swigc__p_wxQuantize,
60315 _swigc__p_wxQueryNewPaletteEvent,
60316 _swigc__p_wxRealPoint,
60317 _swigc__p_wxRect,
60318 _swigc__p_wxRect2D,
60319 _swigc__p_wxRegion,
60320 _swigc__p_wxScrollEvent,
60321 _swigc__p_wxScrollWinEvent,
60322 _swigc__p_wxSetCursorEvent,
60323 _swigc__p_wxShowEvent,
60324 _swigc__p_wxSize,
60325 _swigc__p_wxSizeEvent,
60326 _swigc__p_wxSizer,
60327 _swigc__p_wxSizerFlags,
60328 _swigc__p_wxSizerItem,
60329 _swigc__p_wxStaticBox,
60330 _swigc__p_wxStaticBoxSizer,
60331 _swigc__p_wxStdDialogButtonSizer,
60332 _swigc__p_wxSysColourChangedEvent,
60333 _swigc__p_wxTGAHandler,
60334 _swigc__p_wxTIFFHandler,
60335 _swigc__p_wxToolTip,
60336 _swigc__p_wxUpdateUIEvent,
60337 _swigc__p_wxValidator,
60338 _swigc__p_wxVisualAttributes,
60339 _swigc__p_wxWindow,
60340 _swigc__p_wxWindowCreateEvent,
60341 _swigc__p_wxWindowDestroyEvent,
60342 _swigc__p_wxXPMHandler,
60343 _swigc__p_wxZipFSHandler,
60344 };
60345
60346
60347 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
60348
60349 static swig_const_info swig_const_table[] = {
60350 {0, 0, 0, 0.0, 0, 0}};
60351
60352 #ifdef __cplusplus
60353 }
60354 #endif
60355 /* -----------------------------------------------------------------------------
60356 * Type initialization:
60357 * This problem is tough by the requirement that no dynamic
60358 * memory is used. Also, since swig_type_info structures store pointers to
60359 * swig_cast_info structures and swig_cast_info structures store pointers back
60360 * to swig_type_info structures, we need some lookup code at initialization.
60361 * The idea is that swig generates all the structures that are needed.
60362 * The runtime then collects these partially filled structures.
60363 * The SWIG_InitializeModule function takes these initial arrays out of
60364 * swig_module, and does all the lookup, filling in the swig_module.types
60365 * array with the correct data and linking the correct swig_cast_info
60366 * structures together.
60367 *
60368 * The generated swig_type_info structures are assigned staticly to an initial
60369 * array. We just loop though that array, and handle each type individually.
60370 * First we lookup if this type has been already loaded, and if so, use the
60371 * loaded structure instead of the generated one. Then we have to fill in the
60372 * cast linked list. The cast data is initially stored in something like a
60373 * two-dimensional array. Each row corresponds to a type (there are the same
60374 * number of rows as there are in the swig_type_initial array). Each entry in
60375 * a column is one of the swig_cast_info structures for that type.
60376 * The cast_initial array is actually an array of arrays, because each row has
60377 * a variable number of columns. So to actually build the cast linked list,
60378 * we find the array of casts associated with the type, and loop through it
60379 * adding the casts to the list. The one last trick we need to do is making
60380 * sure the type pointer in the swig_cast_info struct is correct.
60381 *
60382 * First off, we lookup the cast->type name to see if it is already loaded.
60383 * There are three cases to handle:
60384 * 1) If the cast->type has already been loaded AND the type we are adding
60385 * casting info to has not been loaded (it is in this module), THEN we
60386 * replace the cast->type pointer with the type pointer that has already
60387 * been loaded.
60388 * 2) If BOTH types (the one we are adding casting info to, and the
60389 * cast->type) are loaded, THEN the cast info has already been loaded by
60390 * the previous module so we just ignore it.
60391 * 3) Finally, if cast->type has not already been loaded, then we add that
60392 * swig_cast_info to the linked list (because the cast->type) pointer will
60393 * be correct.
60394 * ----------------------------------------------------------------------------- */
60395
60396 #ifdef __cplusplus
60397 extern "C" {
60398 #if 0
60399 } /* c-mode */
60400 #endif
60401 #endif
60402
60403 #if 0
60404 #define SWIGRUNTIME_DEBUG
60405 #endif
60406
60407 SWIGRUNTIME void
60408 SWIG_InitializeModule(void *clientdata) {
60409 size_t i;
60410 swig_module_info *module_head;
60411 static int init_run = 0;
60412
60413 clientdata = clientdata;
60414
60415 if (init_run) return;
60416 init_run = 1;
60417
60418 /* Initialize the swig_module */
60419 swig_module.type_initial = swig_type_initial;
60420 swig_module.cast_initial = swig_cast_initial;
60421
60422 /* Try and load any already created modules */
60423 module_head = SWIG_GetModule(clientdata);
60424 if (module_head) {
60425 swig_module.next = module_head->next;
60426 module_head->next = &swig_module;
60427 } else {
60428 /* This is the first module loaded */
60429 swig_module.next = &swig_module;
60430 SWIG_SetModule(clientdata, &swig_module);
60431 }
60432
60433 /* Now work on filling in swig_module.types */
60434 #ifdef SWIGRUNTIME_DEBUG
60435 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
60436 #endif
60437 for (i = 0; i < swig_module.size; ++i) {
60438 swig_type_info *type = 0;
60439 swig_type_info *ret;
60440 swig_cast_info *cast;
60441
60442 #ifdef SWIGRUNTIME_DEBUG
60443 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60444 #endif
60445
60446 /* if there is another module already loaded */
60447 if (swig_module.next != &swig_module) {
60448 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
60449 }
60450 if (type) {
60451 /* Overwrite clientdata field */
60452 #ifdef SWIGRUNTIME_DEBUG
60453 printf("SWIG_InitializeModule: found type %s\n", type->name);
60454 #endif
60455 if (swig_module.type_initial[i]->clientdata) {
60456 type->clientdata = swig_module.type_initial[i]->clientdata;
60457 #ifdef SWIGRUNTIME_DEBUG
60458 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
60459 #endif
60460 }
60461 } else {
60462 type = swig_module.type_initial[i];
60463 }
60464
60465 /* Insert casting types */
60466 cast = swig_module.cast_initial[i];
60467 while (cast->type) {
60468 /* Don't need to add information already in the list */
60469 ret = 0;
60470 #ifdef SWIGRUNTIME_DEBUG
60471 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
60472 #endif
60473 if (swig_module.next != &swig_module) {
60474 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
60475 #ifdef SWIGRUNTIME_DEBUG
60476 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
60477 #endif
60478 }
60479 if (ret) {
60480 if (type == swig_module.type_initial[i]) {
60481 #ifdef SWIGRUNTIME_DEBUG
60482 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
60483 #endif
60484 cast->type = ret;
60485 ret = 0;
60486 } else {
60487 /* Check for casting already in the list */
60488 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
60489 #ifdef SWIGRUNTIME_DEBUG
60490 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
60491 #endif
60492 if (!ocast) ret = 0;
60493 }
60494 }
60495
60496 if (!ret) {
60497 #ifdef SWIGRUNTIME_DEBUG
60498 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
60499 #endif
60500 if (type->cast) {
60501 type->cast->prev = cast;
60502 cast->next = type->cast;
60503 }
60504 type->cast = cast;
60505 }
60506 cast++;
60507 }
60508 /* Set entry in modules->types array equal to the type */
60509 swig_module.types[i] = type;
60510 }
60511 swig_module.types[i] = 0;
60512
60513 #ifdef SWIGRUNTIME_DEBUG
60514 printf("**** SWIG_InitializeModule: Cast List ******\n");
60515 for (i = 0; i < swig_module.size; ++i) {
60516 int j = 0;
60517 swig_cast_info *cast = swig_module.cast_initial[i];
60518 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60519 while (cast->type) {
60520 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
60521 cast++;
60522 ++j;
60523 }
60524 printf("---- Total casts: %d\n",j);
60525 }
60526 printf("**** SWIG_InitializeModule: Cast List ******\n");
60527 #endif
60528 }
60529
60530 /* This function will propagate the clientdata field of type to
60531 * any new swig_type_info structures that have been added into the list
60532 * of equivalent types. It is like calling
60533 * SWIG_TypeClientData(type, clientdata) a second time.
60534 */
60535 SWIGRUNTIME void
60536 SWIG_PropagateClientData(void) {
60537 size_t i;
60538 swig_cast_info *equiv;
60539 static int init_run = 0;
60540
60541 if (init_run) return;
60542 init_run = 1;
60543
60544 for (i = 0; i < swig_module.size; i++) {
60545 if (swig_module.types[i]->clientdata) {
60546 equiv = swig_module.types[i]->cast;
60547 while (equiv) {
60548 if (!equiv->converter) {
60549 if (equiv->type && !equiv->type->clientdata)
60550 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
60551 }
60552 equiv = equiv->next;
60553 }
60554 }
60555 }
60556 }
60557
60558 #ifdef __cplusplus
60559 #if 0
60560 {
60561 /* c-mode */
60562 #endif
60563 }
60564 #endif
60565
60566
60567
60568 #ifdef __cplusplus
60569 extern "C" {
60570 #endif
60571
60572 /* Python-specific SWIG API */
60573 #define SWIG_newvarlink() SWIG_Python_newvarlink()
60574 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
60575 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
60576
60577 /* -----------------------------------------------------------------------------
60578 * global variable support code.
60579 * ----------------------------------------------------------------------------- */
60580
60581 typedef struct swig_globalvar {
60582 char *name; /* Name of global variable */
60583 PyObject *(*get_attr)(void); /* Return the current value */
60584 int (*set_attr)(PyObject *); /* Set the value */
60585 struct swig_globalvar *next;
60586 } swig_globalvar;
60587
60588 typedef struct swig_varlinkobject {
60589 PyObject_HEAD
60590 swig_globalvar *vars;
60591 } swig_varlinkobject;
60592
60593 SWIGINTERN PyObject *
60594 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
60595 return PyString_FromString("<Swig global variables>");
60596 }
60597
60598 SWIGINTERN PyObject *
60599 swig_varlink_str(swig_varlinkobject *v) {
60600 PyObject *str = PyString_FromString("(");
60601 swig_globalvar *var;
60602 for (var = v->vars; var; var=var->next) {
60603 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
60604 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
60605 }
60606 PyString_ConcatAndDel(&str,PyString_FromString(")"));
60607 return str;
60608 }
60609
60610 SWIGINTERN int
60611 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
60612 PyObject *str = swig_varlink_str(v);
60613 fprintf(fp,"Swig global variables ");
60614 fprintf(fp,"%s\n", PyString_AsString(str));
60615 Py_DECREF(str);
60616 return 0;
60617 }
60618
60619 SWIGINTERN void
60620 swig_varlink_dealloc(swig_varlinkobject *v) {
60621 swig_globalvar *var = v->vars;
60622 while (var) {
60623 swig_globalvar *n = var->next;
60624 free(var->name);
60625 free(var);
60626 var = n;
60627 }
60628 }
60629
60630 SWIGINTERN PyObject *
60631 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
60632 PyObject *res = NULL;
60633 swig_globalvar *var = v->vars;
60634 while (var) {
60635 if (strcmp(var->name,n) == 0) {
60636 res = (*var->get_attr)();
60637 break;
60638 }
60639 var = var->next;
60640 }
60641 if (res == NULL && !PyErr_Occurred()) {
60642 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60643 }
60644 return res;
60645 }
60646
60647 SWIGINTERN int
60648 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
60649 int res = 1;
60650 swig_globalvar *var = v->vars;
60651 while (var) {
60652 if (strcmp(var->name,n) == 0) {
60653 res = (*var->set_attr)(p);
60654 break;
60655 }
60656 var = var->next;
60657 }
60658 if (res == 1 && !PyErr_Occurred()) {
60659 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60660 }
60661 return res;
60662 }
60663
60664 SWIGINTERN PyTypeObject*
60665 swig_varlink_type(void) {
60666 static char varlink__doc__[] = "Swig var link object";
60667 static PyTypeObject varlink_type;
60668 static int type_init = 0;
60669 if (!type_init) {
60670 const PyTypeObject tmp
60671 = {
60672 PyObject_HEAD_INIT(NULL)
60673 0, /* Number of items in variable part (ob_size) */
60674 (char *)"swigvarlink", /* Type name (tp_name) */
60675 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
60676 0, /* Itemsize (tp_itemsize) */
60677 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
60678 (printfunc) swig_varlink_print, /* Print (tp_print) */
60679 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
60680 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
60681 0, /* tp_compare */
60682 (reprfunc) swig_varlink_repr, /* tp_repr */
60683 0, /* tp_as_number */
60684 0, /* tp_as_sequence */
60685 0, /* tp_as_mapping */
60686 0, /* tp_hash */
60687 0, /* tp_call */
60688 (reprfunc)swig_varlink_str, /* tp_str */
60689 0, /* tp_getattro */
60690 0, /* tp_setattro */
60691 0, /* tp_as_buffer */
60692 0, /* tp_flags */
60693 varlink__doc__, /* tp_doc */
60694 0, /* tp_traverse */
60695 0, /* tp_clear */
60696 0, /* tp_richcompare */
60697 0, /* tp_weaklistoffset */
60698 #if PY_VERSION_HEX >= 0x02020000
60699 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
60700 #endif
60701 #if PY_VERSION_HEX >= 0x02030000
60702 0, /* tp_del */
60703 #endif
60704 #ifdef COUNT_ALLOCS
60705 0,0,0,0 /* tp_alloc -> tp_next */
60706 #endif
60707 };
60708 varlink_type = tmp;
60709 varlink_type.ob_type = &PyType_Type;
60710 type_init = 1;
60711 }
60712 return &varlink_type;
60713 }
60714
60715 /* Create a variable linking object for use later */
60716 SWIGINTERN PyObject *
60717 SWIG_Python_newvarlink(void) {
60718 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
60719 if (result) {
60720 result->vars = 0;
60721 }
60722 return ((PyObject*) result);
60723 }
60724
60725 SWIGINTERN void
60726 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
60727 swig_varlinkobject *v = (swig_varlinkobject *) p;
60728 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
60729 if (gv) {
60730 size_t size = strlen(name)+1;
60731 gv->name = (char *)malloc(size);
60732 if (gv->name) {
60733 strncpy(gv->name,name,size);
60734 gv->get_attr = get_attr;
60735 gv->set_attr = set_attr;
60736 gv->next = v->vars;
60737 }
60738 }
60739 v->vars = gv;
60740 }
60741
60742 SWIGINTERN PyObject *
60743 SWIG_globals() {
60744 static PyObject *_SWIG_globals = 0;
60745 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
60746 return _SWIG_globals;
60747 }
60748
60749 /* -----------------------------------------------------------------------------
60750 * constants/methods manipulation
60751 * ----------------------------------------------------------------------------- */
60752
60753 /* Install Constants */
60754 SWIGINTERN void
60755 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
60756 PyObject *obj = 0;
60757 size_t i;
60758 for (i = 0; constants[i].type; ++i) {
60759 switch(constants[i].type) {
60760 case SWIG_PY_POINTER:
60761 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
60762 break;
60763 case SWIG_PY_BINARY:
60764 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
60765 break;
60766 default:
60767 obj = 0;
60768 break;
60769 }
60770 if (obj) {
60771 PyDict_SetItemString(d, constants[i].name, obj);
60772 Py_DECREF(obj);
60773 }
60774 }
60775 }
60776
60777 /* -----------------------------------------------------------------------------*/
60778 /* Fix SwigMethods to carry the callback ptrs when needed */
60779 /* -----------------------------------------------------------------------------*/
60780
60781 SWIGINTERN void
60782 SWIG_Python_FixMethods(PyMethodDef *methods,
60783 swig_const_info *const_table,
60784 swig_type_info **types,
60785 swig_type_info **types_initial) {
60786 size_t i;
60787 for (i = 0; methods[i].ml_name; ++i) {
60788 const char *c = methods[i].ml_doc;
60789 if (c && (c = strstr(c, "swig_ptr: "))) {
60790 int j;
60791 swig_const_info *ci = 0;
60792 const char *name = c + 10;
60793 for (j = 0; const_table[j].type; ++j) {
60794 if (strncmp(const_table[j].name, name,
60795 strlen(const_table[j].name)) == 0) {
60796 ci = &(const_table[j]);
60797 break;
60798 }
60799 }
60800 if (ci) {
60801 size_t shift = (ci->ptype) - types;
60802 swig_type_info *ty = types_initial[shift];
60803 size_t ldoc = (c - methods[i].ml_doc);
60804 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
60805 char *ndoc = (char*)malloc(ldoc + lptr + 10);
60806 if (ndoc) {
60807 char *buff = ndoc;
60808 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
60809 if (ptr) {
60810 strncpy(buff, methods[i].ml_doc, ldoc);
60811 buff += ldoc;
60812 strncpy(buff, "swig_ptr: ", 10);
60813 buff += 10;
60814 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
60815 methods[i].ml_doc = ndoc;
60816 }
60817 }
60818 }
60819 }
60820 }
60821 }
60822
60823 #ifdef __cplusplus
60824 }
60825 #endif
60826
60827 /* -----------------------------------------------------------------------------*
60828 * Partial Init method
60829 * -----------------------------------------------------------------------------*/
60830
60831 #ifdef __cplusplus
60832 extern "C"
60833 #endif
60834 SWIGEXPORT void SWIG_init(void) {
60835 PyObject *m, *d;
60836
60837 /* Fix SwigMethods to carry the callback ptrs when needed */
60838 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
60839
60840 m = Py_InitModule((char *) SWIG_name, SwigMethods);
60841 d = PyModule_GetDict(m);
60842
60843 SWIG_InitializeModule(0);
60844 SWIG_InstallConstants(d,swig_const_table);
60845
60846
60847
60848 #ifndef wxPyUSE_EXPORT
60849 // Make our API structure a CObject so other modules can import it
60850 // from this module.
60851 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
60852 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
60853 Py_XDECREF(cobj);
60854 #endif
60855
60856 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
60857 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
60858 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
60859 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
60860 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
60861 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
60862 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
60863 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
60864 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
60865 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
60866 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
60867 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
60868 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
60869 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
60870 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
60871 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
60872 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
60873 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
60874 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
60875 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
60876 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
60877 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
60878 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
60879 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
60880 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
60881 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
60882 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
60883 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
60884 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
60885 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
60886 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
60887 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
60888 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
60889 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
60890 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
60891 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
60892 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
60893 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
60894 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
60895 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
60896 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
60897 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
60898 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
60899 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
60900 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
60901 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
60902 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
60903 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
60904 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
60905 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
60906 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
60907 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
60908 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
60909 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
60910 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
60911 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
60912 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
60913 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
60914 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
60915 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
60916 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
60917 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
60918 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
60919 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
60920 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
60921 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
60922 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
60923 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
60924 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
60925 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
60926 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
60927 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
60928 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
60929 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
60930 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
60931 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
60932 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
60933 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
60934 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
60935 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
60936 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
60937 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
60938 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
60939 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
60940 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
60941 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
60942 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
60943 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
60944 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
60945 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
60946 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
60947 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
60948 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
60949 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
60950 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
60951 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
60952 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
60953 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
60954 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
60955 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
60956 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
60957 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
60958 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
60959 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
60960 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
60961 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
60962 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
60963 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
60964 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
60965 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
60966 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
60967 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
60968 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
60969 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
60970 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
60971 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
60972 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
60973 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
60974 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
60975 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
60976 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
60977 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
60978 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
60979 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
60980 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
60981 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
60982 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
60983 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
60984 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
60985 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
60986 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
60987 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
60988 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
60989 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
60990 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
60991 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
60992 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
60993 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
60994 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
60995 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
60996 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
60997 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
60998 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
60999 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61000 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61001 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61002 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61003 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61004 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61005 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61006 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61007 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61008 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61009 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61010 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61011 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61012 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61013 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61014 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61015 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61016 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61017 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61018 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61019 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61020 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61021 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61022 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61023 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61024 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61025 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61026 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61027 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61028 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61029 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61030 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61031 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61032 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61033 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61034 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61035 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61036 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61037 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61038 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61039 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61040 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61041 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61042 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61043 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61044 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61045 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61046 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61047 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61048 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61049 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61050 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61051 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61052 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61053 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61054 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61055 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61056 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61057 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61058 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61059 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61060 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61061 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61062 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61063 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61064 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61065 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61066 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61067 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61068 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61069 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61070 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61071 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61072 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61073 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61074 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61075 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61076 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61077 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61078 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61079 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61080 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61081 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61082 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61083 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61084 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61085 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61086 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61087 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61088 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61089 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61090 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61091 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61092 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61093 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61094 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61095 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61096 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61097 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61098 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61099 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61100 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61101 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61102 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61103 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61104 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61105 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61106 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61107 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61108 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61109 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61110 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61111 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61112 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61113 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61114 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61115 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61116 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61117 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61118 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61119 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61120 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61121 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61122 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61123 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61124 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61125 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61126 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61127 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61128 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61129 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61130 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61131 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61132 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61133 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61134 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61135 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61136 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61137 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61138 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61139 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61140 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61141 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61142 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61143 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61144 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61145 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61146 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61147 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61148 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61149 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61150 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61151 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61152 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61153 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61154 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61155 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61156 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61157 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61158 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61159 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61160 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61161 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61162 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61163 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61164 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61165 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61166 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61167 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61168 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61169 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61170 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61171 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61172 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61173 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61174 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61175 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61176 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61177 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61178 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61179 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61180 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61181 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61182 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61183 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61184 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61185 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61186 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61187 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61188 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61189 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61190 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61191 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61192 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61193 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61194 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61195 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61196 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61197 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61198 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61199 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61200 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61201 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61202 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61203 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61204 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61205 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61206 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61207 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61208 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61209 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61210 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61211 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61212 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61213 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61214 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61215 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61216 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61217 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61218 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61219 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61220 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61221 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61222 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61223 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61224 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61225 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61226 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61227 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61228 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61229 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61230 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61231 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61232 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61233 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61234 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61235 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61236 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61237 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61238 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61239 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61240 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61241 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61242 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61243 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61244 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61245 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61246 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61247 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61248 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61249 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61250 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61251 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61252 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61253 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61254 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61255 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61256 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61257 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61258 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61259 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61260 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61261 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61262 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61263 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61264 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61265 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61266 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61267 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61268 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61269 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61270 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61271 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61272 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61273 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61274 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61275 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61276 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61277 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61278 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61279 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61280 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61281 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61282 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61283 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
61284 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
61285 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
61286 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
61287 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
61288 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
61289 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
61290 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
61291 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
61292 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
61293 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
61294 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
61295 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
61296 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
61297 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
61298 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
61299 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
61300 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
61301 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
61302 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
61303 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
61304 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
61305 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
61306 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
61307 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
61308 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
61309 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
61310 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
61311 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
61312 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
61313 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
61314 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
61315 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
61316 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
61317 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
61318 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
61319 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
61320 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
61321 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
61322 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
61323 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
61324 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
61325 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
61326 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
61327 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
61328 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
61329 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
61330 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
61331 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
61332 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
61333 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
61334 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
61335 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
61336 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
61337 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
61338 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
61339 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
61340 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
61341 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
61342 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
61343 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
61344 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
61345 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
61346 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
61347 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
61348 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
61349 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
61350 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
61351 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
61352 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
61353 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
61354 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
61355 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
61356 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
61357 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
61358 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
61359 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
61360 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
61361 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
61362 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
61363 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
61364 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
61365 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
61366 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
61367 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
61368 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
61369 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
61370 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
61371 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
61372 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
61373 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
61374 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
61375 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
61376 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
61377 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
61378 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
61379 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
61380 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
61381 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
61382 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
61383 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
61384 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
61385 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
61386 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
61387 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
61388 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
61389 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
61390 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
61391 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
61392 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
61393 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
61394 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
61395 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
61396 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
61397 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
61398 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
61399 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
61400 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
61401 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
61402 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
61403 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
61404 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
61405 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
61406 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
61407 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
61408 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
61409 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
61410 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
61411 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
61412 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
61413 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
61414 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
61415 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
61416 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
61417 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
61418 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
61419 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
61420 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
61421 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
61422 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
61423 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
61424 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
61425 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
61426 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
61427 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
61428 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
61429 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
61430 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
61431 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
61432 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
61433 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
61434 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
61435 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
61436 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
61437 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
61438 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
61439 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
61440 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
61441 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
61442 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
61443 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
61444 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
61445 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
61446 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
61447 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
61448 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
61449 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
61450 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
61451 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
61452 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
61453 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
61454 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
61455 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
61456 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
61457 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
61458 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
61459 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
61460 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
61461 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
61462 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
61463 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
61464 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
61465 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
61466 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
61467 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
61468 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
61469 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
61470 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
61471 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
61472 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
61473 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
61474 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
61475 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
61476 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
61477 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
61478 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
61479 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
61480 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
61481 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
61482 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
61483 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
61484 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
61485 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
61486 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
61487 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
61488 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
61489 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
61490 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
61491 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
61492 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
61493 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
61494 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
61495 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
61496 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
61497 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
61498 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
61499 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
61500 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
61501 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
61502 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
61503 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
61504 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
61505 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
61506 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
61507 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
61508 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
61509 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
61510 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
61511 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
61512 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
61513 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
61514
61515 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
61516
61517
61518 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
61519
61520 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
61521 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
61522 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
61523 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
61524 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
61525 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
61526 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
61527 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
61528 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
61529 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
61530 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
61531 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
61532 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
61533 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
61534 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
61535 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
61536 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
61537 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
61538 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
61539 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
61540 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
61541 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
61542 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
61543 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
61544 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
61545 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
61546 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
61547 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
61548 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
61549 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
61550 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
61551 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
61552 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
61553 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
61554 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
61555 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
61556 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
61557 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
61558 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
61559 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
61560 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
61561 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
61562 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
61563 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
61564 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
61565 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
61566 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
61567 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
61568 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
61569 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
61570 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
61571 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
61572 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
61573 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
61574 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
61575 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
61576 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
61577 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
61578 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
61579 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
61580 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
61581 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
61582 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
61583 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
61584 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
61585 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
61586 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
61587 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
61588 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
61589 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
61590 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
61591 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
61592 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
61593 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
61594 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
61595 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
61596 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
61597 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
61598 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
61599 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
61600 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
61601 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
61602 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
61603 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
61604 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
61605 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
61606 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
61607 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
61608 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
61609 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
61610 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
61611 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
61612 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
61613 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
61614 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
61615 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
61616 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
61617 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
61618 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
61619 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
61620 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
61621 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
61622 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
61623 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
61624 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
61625 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
61626 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
61627 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
61628 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
61629 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
61630 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
61631 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
61632 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
61633 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
61634 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
61635 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
61636 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
61637 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
61638 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
61639 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
61640 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
61641 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
61642 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
61643 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
61644 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
61645 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
61646 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
61647 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
61648 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
61649 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
61650 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
61651 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
61652 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
61653 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
61654 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
61655 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
61656 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
61657 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
61658 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
61659 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
61660 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
61661 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
61662 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
61663 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
61664 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
61665 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
61666 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
61667 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
61668 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
61669 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
61670 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
61671 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
61672 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
61673 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
61674 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
61675 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
61676 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
61677 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
61678 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
61679 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
61680 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
61681 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
61682 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
61683 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
61684 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
61685 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
61686 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
61687 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
61688 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
61689 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
61690 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
61691 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
61692 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
61693 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
61694 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
61695 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
61696 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
61697 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
61698 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
61699 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
61700 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
61701 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
61702 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
61703 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
61704 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
61705 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
61706 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
61707 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
61708 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
61709 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
61710 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
61711 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
61712 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
61713 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
61714 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
61715 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
61716 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
61717 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
61718 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
61719 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
61720 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
61721 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
61722 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
61723 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
61724 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
61725 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
61726 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
61727 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
61728 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
61729 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
61730 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
61731 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
61732 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
61733 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
61734 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
61735
61736 // Initialize threading, some globals and such
61737 __wxPyPreStart(d);
61738
61739
61740 // Although these are defined in __version__ they need to be here too so
61741 // that an assert can be done to ensure that the wxPython and the wxWindows
61742 // versions match.
61743 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
61744 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
61745 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
61746
61747 }
61748
wxWidgets (Impactor)